void MessageManagerGlobal::Dump(const nsAString& aStr) { if (!DOMPrefs::DumpEnabled()) { return; } #ifdef ANDROID __android_log_print(ANDROID_LOG_INFO, "Gecko", "%s", NS_ConvertUTF16toUTF8(aStr).get()); #endif #ifdef XP_WIN if (IsDebuggerPresent()) { OutputDebugStringW(PromiseFlatString(aStr).get()); } #endif fputs(NS_ConvertUTF16toUTF8(aStr).get(), stdout); fflush(stdout); }
NS_IMETHODIMP nsCollationMacUC::AllocateRawSortKey(int32_t strength, const nsAString& stringIn, uint8_t** key, uint32_t* outLen) { NS_ENSURE_TRUE(mInit, NS_ERROR_NOT_INITIALIZED); NS_ENSURE_ARG_POINTER(key); NS_ENSURE_ARG_POINTER(outLen); nsresult res = EnsureCollator(strength); NS_ENSURE_SUCCESS(res, res); uint32_t stringInLen = stringIn.Length(); uint32_t maxKeyLen = (1 + stringInLen) * kCollationValueSizeFactor * sizeof(UCCollationValue); if (maxKeyLen > mBufferLen) { uint32_t newBufferLen = mBufferLen; do { newBufferLen *= 2; } while (newBufferLen < maxKeyLen); void *newBuffer = PR_Malloc(newBufferLen); if (!newBuffer) return NS_ERROR_OUT_OF_MEMORY; PR_FREEIF(mBuffer); mBuffer = newBuffer; mBufferLen = newBufferLen; } ItemCount actual; OSStatus err = ::UCGetCollationKey(mCollator, (const UniChar*) PromiseFlatString(stringIn).get(), (UniCharCount) stringInLen, (ItemCount) (mBufferLen / sizeof(UCCollationValue)), &actual, (UCCollationValue *)mBuffer); NS_ENSURE_TRUE((err == noErr), NS_ERROR_FAILURE); uint32_t keyLength = actual * sizeof(UCCollationValue); void *newKey = PR_Malloc(keyLength); if (!newKey) return NS_ERROR_OUT_OF_MEMORY; memcpy(newKey, mBuffer, keyLength); *key = (uint8_t *)newKey; *outLen = keyLength; return NS_OK; }
/* helper routine. Iterate over the passed in settings object. */ PRBool nsWindowsShellService::TestForDefault(SETTING aSettings[], PRInt32 aSize) { PRBool isDefault = PR_TRUE; PRUnichar currValue[MAX_BUF]; SETTING* end = aSettings + aSize; for (SETTING * settings = aSettings; settings < end; ++settings) { NS_ConvertUTF8toUTF16 dataLongPath(settings->valueData); NS_ConvertUTF8toUTF16 key(settings->keyName); NS_ConvertUTF8toUTF16 value(settings->valueName); if (settings->flags & APP_PATH_SUBSTITUTION) { PRInt32 offset = dataLongPath.Find("%APPPATH%"); dataLongPath.Replace(offset, 9, mAppLongPath); } ::ZeroMemory(currValue, sizeof(currValue)); HKEY theKey; nsresult rv = OpenKeyForReading(HKEY_CLASSES_ROOT, key, &theKey); if (NS_FAILED(rv)) { // Key doesn't exist isDefault = PR_FALSE; break; } DWORD len = sizeof currValue; DWORD result = ::RegQueryValueExW(theKey, PromiseFlatString(value).get(), NULL, NULL, (LPBYTE)currValue, &len); // Close the key we opened. ::RegCloseKey(theKey); if (REG_FAILED(result) || !dataLongPath.Equals(currValue, nsCaseInsensitiveStringComparator())) { // Key wasn't set, or was set to something else (something else became the default client) isDefault = PR_FALSE; break; } } // for each registry key we want to look at return isDefault; }
PRInt32 nsStaticCaseInsensitiveNameTable::Lookup(const nsAString& aName) { NS_ASSERTION(mNameArray, "not inited"); NS_ASSERTION(mNameTable.ops, "not inited"); const nsAFlatString& str = PromiseFlatString(aName); NameTableKey key(&str); NameTableEntry *entry = static_cast<NameTableEntry*> (PL_DHashTableOperate(&mNameTable, &key, PL_DHASH_LOOKUP)); if (PL_DHASH_ENTRY_IS_FREE(entry)) return nsStaticCaseInsensitiveNameTable::NOT_FOUND; return entry->mIndex; }
static void CheckTlbPath(JSONWriter& aJson, const nsAString& aTypelibPath) { const nsString& flatPath = PromiseFlatString(aTypelibPath); DWORD bufCharLen = ExpandEnvironmentStrings(flatPath.get(), nullptr, 0); auto buf = MakeUnique<WCHAR[]>(bufCharLen); if (!ExpandEnvironmentStrings(flatPath.get(), buf.get(), bufCharLen)) { return; } // See whether this tlb can actually be loaded RefPtr<ITypeLib> typeLib; HRESULT hr = LoadTypeLibEx(buf.get(), REGKIND_NONE, getter_AddRefs(typeLib)); nsPrintfCString loadResult("0x%08X", hr); aJson.StringProperty("LoadResult", loadResult.get()); }
static bool ParseInteger(nsDependentSubstring& aString, int32_t& aResult) { uint32_t index = FirstNonDigit(aString, 0); if (index == 0) { return false; } nsDependentSubstring n(aString, 0, index); nsresult ec; int32_t s = PromiseFlatString(n).ToInteger(&ec); if (NS_FAILED(ec)) { return false; } aString.Rebind(aString, index); aResult = s; return true; }
nsresult nsWyciwygChannel::WriteToCacheEntryInternal(const nsAString &aData, const nsACString& spec) { NS_ASSERTION(IsOnCacheIOThread(), "wrong thread"); nsresult rv; if (!mCacheEntry) { rv = OpenCacheEntry(spec, nsICache::ACCESS_WRITE); if (NS_FAILED(rv)) return rv; } if (mLoadFlags & INHIBIT_PERSISTENT_CACHING) { rv = mCacheEntry->SetMetaDataElement("inhibit-persistent-caching", "1"); if (NS_FAILED(rv)) return rv; } if (mSecurityInfo) { mCacheEntry->SetSecurityInfo(mSecurityInfo); } if (mNeedToWriteCharset) { WriteCharsetAndSourceToCache(mCharsetSource, mCharset); mNeedToWriteCharset = false; } PRUint32 out; if (!mCacheOutputStream) { // Get the outputstream from the cache entry. rv = mCacheEntry->OpenOutputStream(0, getter_AddRefs(mCacheOutputStream)); if (NS_FAILED(rv)) return rv; // Write out a Byte Order Mark, so that we'll know if the data is // BE or LE when we go to read it. PRUnichar bom = 0xFEFF; rv = mCacheOutputStream->Write((char *)&bom, sizeof(bom), &out); if (NS_FAILED(rv)) return rv; } return mCacheOutputStream->Write((char *)PromiseFlatString(aData).get(), aData.Length() * sizeof(PRUnichar), &out); }
NS_IMETHODIMP mozSpellChecker::SetCurrentDictionary(const nsAString &aDictionary) { if(!mSpellCheckingEngine) return NS_ERROR_NULL_POINTER; nsresult res; res = mSpellCheckingEngine->SetDictionary(PromiseFlatString(aDictionary).get()); if(NS_FAILED(res)){ NS_WARNING("Dictionary load failed"); return res; } nsXPIDLString language; nsCOMPtr<mozISpellI18NManager> serv(do_GetService("@mozilla.org/spellchecker/i18nmanager;1", &res)); if(serv && NS_SUCCEEDED(res)){ res = serv->GetUtil(language.get(),getter_AddRefs(mConverter)); } return res; }
static void logMessage(nsIContent* aContent, const nsAString& aCoordsSpec, PRInt32 aFlags, const char* aMessageName) { nsIDocument* doc = aContent->GetOwnerDoc(); nsContentUtils::ReportToConsole( nsContentUtils::eLAYOUT_PROPERTIES, aMessageName, nsnull, /* params */ 0, /* params length */ nsnull, PromiseFlatString(NS_LITERAL_STRING("coords=\"") + aCoordsSpec + NS_LITERAL_STRING("\"")), /* source line */ 0, /* line number */ 0, /* column number */ aFlags, "ImageMap", doc); }
NS_IMETHODIMP nsWindowsRegKey::HasChild(const nsAString& aName, bool* aResult) { if (NS_WARN_IF(!mKey)) { return NS_ERROR_NOT_INITIALIZED; } // Check for the existence of a child key by opening the key with minimal // rights. Perhaps there is a more efficient way to do this? HKEY key; LONG rv = RegOpenKeyExW(mKey, PromiseFlatString(aName).get(), 0, STANDARD_RIGHTS_READ, &key); if ((*aResult = (rv == ERROR_SUCCESS && key))) { RegCloseKey(key); } return NS_OK; }
NS_IMETHODIMP nsWindowsRegKey::ReadStringValue(const nsAString &name, nsAString &result) { NS_ENSURE_TRUE(mKey, NS_ERROR_NOT_INITIALIZED); DWORD type, size; const nsString &flatName = PromiseFlatString(name); LONG rv = RegQueryValueExW(mKey, flatName.get(), 0, &type, NULL, &size); if (rv != ERROR_SUCCESS) return NS_ERROR_FAILURE; // This must be a string type in order to fetch the value as a string. // We're being a bit forgiving here by allowing types other than REG_SZ. NS_ENSURE_STATE(type == REG_SZ || type == REG_EXPAND_SZ || type == REG_MULTI_SZ); // The buffer size must be a multiple of 2. NS_ENSURE_STATE(size % 2 == 0); if (size == 0) { result.Truncate(); return NS_OK; } // |size| includes room for the terminating null character DWORD resultLen = size / 2 - 1; result.SetLength(resultLen); nsAString::iterator begin; result.BeginWriting(begin); if (begin.size_forward() != resultLen) return NS_ERROR_OUT_OF_MEMORY; rv = RegQueryValueExW(mKey, flatName.get(), 0, NULL, (LPBYTE) begin.get(), &size); return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE; }
//------------------------------------------------------------------------- char * nsFilePicker::ConvertToFileSystemCharset(const nsAString& inString) { char *outString = nsnull; nsresult rv = NS_OK; // get file system charset and create a unicode encoder if (nsnull == mUnicodeEncoder) { nsCAutoString fileSystemCharset; GetFileSystemCharset(fileSystemCharset); nsCOMPtr<nsICharsetConverterManager> ccm = do_GetService(NS_CHARSETCONVERTERMANAGER_CONTRACTID, &rv); if (NS_SUCCEEDED(rv)) { rv = ccm->GetUnicodeEncoderRaw(fileSystemCharset.get(), &mUnicodeEncoder); } } // converts from unicode to the file system charset if (NS_SUCCEEDED(rv)) { PRInt32 inLength = inString.Length(); const nsAFlatString& flatInString = PromiseFlatString(inString); PRInt32 outLength; rv = mUnicodeEncoder->GetMaxLength(flatInString.get(), inLength, &outLength); if (NS_SUCCEEDED(rv)) { outString = static_cast<char*>(nsMemory::Alloc( outLength+1 )); if (nsnull == outString) { return nsnull; } rv = mUnicodeEncoder->Convert(flatInString.get(), &inLength, outString, &outLength); if (NS_SUCCEEDED(rv)) { outString[outLength] = '\0'; } } } return NS_SUCCEEDED(rv) ? outString : nsnull; }
nsresult nsJSUtils::CompileFunction(JSContext* aCx, JS::HandleObject aTarget, JS::CompileOptions& aOptions, const nsACString& aName, uint32_t aArgCount, const char** aArgArray, const nsAString& aBody, JSObject** aFunctionObject) { MOZ_ASSERT(js::GetEnterCompartmentDepth(aCx) > 0); MOZ_ASSERT_IF(aTarget, js::IsObjectInContextCompartment(aTarget, aCx)); MOZ_ASSERT_IF(aOptions.versionSet, aOptions.version != JSVERSION_UNKNOWN); mozilla::DebugOnly<nsIScriptContext*> ctx = GetScriptContextFromJSContext(aCx); MOZ_ASSERT_IF(ctx, ctx->IsContextInitialized()); // Since aTarget and aCx are same-compartment, there should be no distinction // between the object principal and the cx principal. // However, aTarget may be null in the wacky aShared case. So use the cx. JSPrincipals* p = JS_GetCompartmentPrincipals(js::GetContextCompartment(aCx)); aOptions.setPrincipals(p); // Do the junk Gecko is supposed to do before calling into JSAPI. if (aTarget) { JS::ExposeObjectToActiveJS(aTarget); } // Compile. JSFunction* fun = JS::CompileFunction(aCx, aTarget, aOptions, PromiseFlatCString(aName).get(), aArgCount, aArgArray, PromiseFlatString(aBody).get(), aBody.Length()); if (!fun) { ReportPendingException(aCx); return NS_ERROR_FAILURE; } *aFunctionObject = JS_GetFunctionObject(fun); return NS_OK; }
NS_IMETHODIMP mozSpellChecker::SetCurrentDictionary(const nsAString &aDictionary) { // Calls to mozISpellCheckingEngine::SetDictionary might destroy us nsRefPtr<mozSpellChecker> kungFuDeathGrip = this; mSpellCheckingEngine = nullptr; if (aDictionary.IsEmpty()) { return NS_OK; } nsresult rv; nsCOMArray<mozISpellCheckingEngine> spellCheckingEngines; rv = GetEngineList(&spellCheckingEngines); NS_ENSURE_SUCCESS(rv, rv); for (int32_t i = 0; i < spellCheckingEngines.Count(); i++) { // We must set mSpellCheckingEngine before we call SetDictionary, since // SetDictionary calls back to this spell checker to check if the // dictionary was set mSpellCheckingEngine = spellCheckingEngines[i]; rv = mSpellCheckingEngine->SetDictionary(PromiseFlatString(aDictionary).get()); if (NS_SUCCEEDED(rv)) { nsCOMPtr<mozIPersonalDictionary> personalDictionary = do_GetService("@mozilla.org/spellchecker/personaldictionary;1"); mSpellCheckingEngine->SetPersonalDictionary(personalDictionary.get()); nsXPIDLString language; nsCOMPtr<mozISpellI18NManager> serv(do_GetService("@mozilla.org/spellchecker/i18nmanager;1", &rv)); NS_ENSURE_SUCCESS(rv, rv); return serv->GetUtil(language.get(),getter_AddRefs(mConverter)); } } mSpellCheckingEngine = nullptr; // We could not find any engine with the requested dictionary return NS_ERROR_NOT_AVAILABLE; }
bool nsMediaFragmentURIParser::ParseNPTFraction(nsDependentSubstring& aString, double& aFraction) { double fraction = 0.0; if (aString.Length() > 0 && aString[0] == '.') { PRUint32 index = FirstNonDigit(aString, 1); if (index > 1) { nsDependentSubstring number(aString, 0, index); PRInt32 ec; fraction = PromiseFlatString(number).ToDouble(&ec); if (NS_FAILED(ec)) { return PR_FALSE; } } aString.Rebind(aString, index); } aFraction = fraction; return PR_TRUE; }
PRBool nsAttrValue::ParseDoubleValue(const nsAString& aString) { ResetIfSet(); PRInt32 ec; double val = PromiseFlatString(aString).ToDouble(&ec); if (NS_FAILED(ec)) { return PR_FALSE; } if (EnsureEmptyMiscContainer()) { MiscContainer* cont = GetMiscContainer(); cont->mDoubleValue = val; cont->mType = eDoubleValue; nsAutoString serializedFloat; serializedFloat.AppendFloat(val); SetMiscAtomOrString(serializedFloat.Equals(aString) ? nsnull : &aString); return PR_TRUE; } return PR_FALSE; }
bool CSP_IsQuotelessKeyword(const nsAString& aKey) { nsString lowerKey = PromiseFlatString(aKey); ToLowerCase(lowerKey); static_assert(CSP_LAST_KEYWORD_VALUE == (sizeof(CSPStrKeywords) / sizeof(CSPStrKeywords[0])), "CSP_LAST_KEYWORD_VALUE does not match length of CSPStrKeywords"); nsAutoString keyword; for (uint32_t i = 0; i < CSP_LAST_KEYWORD_VALUE; i++) { // skipping the leading ' and trimming the trailing ' keyword.AssignASCII(CSPStrKeywords[i] + 1); keyword.Trim("'", false, true); if (lowerKey.Equals(keyword)) { return true; } } return false; }
NS_IMETHODIMP XPathEvaluator::CreateExpression(const nsAString & aExpression, nsIDOMXPathNSResolver *aResolver, nsIDOMXPathExpression **aResult) { nsresult rv; if (!mRecycler) { nsRefPtr<txResultRecycler> recycler = new txResultRecycler; NS_ENSURE_TRUE(recycler, NS_ERROR_OUT_OF_MEMORY); rv = recycler->init(); NS_ENSURE_SUCCESS(rv, rv); mRecycler = recycler; } nsCOMPtr<nsIDocument> doc = do_QueryReferent(mDocument); XPathEvaluatorParseContext pContext(aResolver, !(doc && doc->IsHTML())); nsAutoPtr<Expr> expression; rv = txExprParser::createExpr(PromiseFlatString(aExpression), &pContext, getter_Transfers(expression)); if (NS_FAILED(rv)) { if (rv == NS_ERROR_DOM_NAMESPACE_ERR) { return NS_ERROR_DOM_NAMESPACE_ERR; } return NS_ERROR_DOM_INVALID_EXPRESSION_ERR; } nsCOMPtr<nsIDOMDocument> document = do_QueryReferent(mDocument); *aResult = new nsXPathExpression(expression, mRecycler, document); if (!*aResult) { return NS_ERROR_OUT_OF_MEMORY; } NS_ADDREF(*aResult); return NS_OK; }
NS_IMETHODIMP nsPersistentProperties::SetStringProperty(const nsACString& aKey, const nsAString& aNewValue, nsAString& aOldValue) { const nsAFlatCString& flatKey = PromiseFlatCString(aKey); PropertyTableEntry* entry = static_cast<PropertyTableEntry*>( PL_DHashTableAdd(&mTable, flatKey.get())); if (entry->mKey) { aOldValue = entry->mValue; NS_WARNING(nsPrintfCString("the property %s already exists\n", flatKey.get()).get()); } else { aOldValue.Truncate(); } entry->mKey = ArenaStrdup(flatKey, &mArena); entry->mValue = ArenaStrdup(PromiseFlatString(aNewValue), &mArena); return NS_OK; }
PRBool nsAttrValue::ParseIntWithBounds(const nsAString& aString, PRInt32 aMin, PRInt32 aMax) { NS_PRECONDITION(aMin < aMax && aMin >= NS_ATTRVALUE_INTEGERTYPE_MINVALUE && aMax <= NS_ATTRVALUE_INTEGERTYPE_MAXVALUE, "bad boundaries"); ResetIfSet(); PRInt32 ec; PRInt32 val = PromiseFlatString(aString).ToInteger(&ec); if (NS_FAILED(ec)) { return PR_FALSE; } val = PR_MAX(val, aMin); val = PR_MIN(val, aMax); SetIntValueAndType(val, eInteger); return PR_TRUE; }
bool nsMediaFragmentURIParser::ParseNPTHH(nsDependentSubstring& aString, uint32_t& aHour) { if (aString.Length() == 0) { return false; } uint32_t index = FirstNonDigit(aString, 0); if (index == 0) { return false; } nsDependentSubstring n(aString, 0, index); nsresult ec; int32_t u = PromiseFlatString(n).ToInteger(&ec); if (NS_FAILED(ec)) { return false; } aString.Rebind(aString, index); aHour = u; return true; }
bool nsMediaFragmentURIParser::ParseNPTHH(nsDependentSubstring& aString, PRUint32& aHour) { if (aString.Length() == 0) { return PR_FALSE; } PRUint32 index = FirstNonDigit(aString, 0); if (index == 0) { return PR_FALSE; } nsDependentSubstring n(aString, 0, index); PRInt32 ec; PRInt32 u = PromiseFlatString(n).ToInteger(&ec); if (NS_FAILED(ec)) { return PR_FALSE; } aString.Rebind(aString, index); aHour = u; return PR_TRUE; }
NS_IMETHODIMP nsDOMWindowList::NamedItem(const nsAString& aName, nsIDOMWindow** aReturn) { nsCOMPtr<nsIDocShellTreeItem> item; *aReturn = nullptr; EnsureFresh(); if (mDocShellNode) { mDocShellNode->FindChildWithName(PromiseFlatString(aName).get(), false, false, nullptr, nullptr, getter_AddRefs(item)); nsCOMPtr<nsIScriptGlobalObject> globalObject(do_GetInterface(item)); if (globalObject) { CallQueryInterface(globalObject.get(), aReturn); } } return NS_OK; }
NS_IMETHODIMP nsNSSDialogs::ShowCertError(nsIInterfaceRequestor *ctx, nsISSLStatus *status, nsIX509Cert *cert, const nsAString & textErrorMessage, const nsAString & htmlErrorMessage, const nsACString & hostName, PRUint32 portNumber) { nsCOMPtr<nsIPKIParamBlock> block = do_CreateInstance(NS_PKIPARAMBLOCK_CONTRACTID); if (!block) return NS_ERROR_OUT_OF_MEMORY; nsCOMPtr<nsIDialogParamBlock> dialogBlock = do_QueryInterface(block); nsresult rv; rv = dialogBlock->SetInt(1, portNumber); if (NS_FAILED(rv)) return rv; rv = dialogBlock->SetString(1, NS_ConvertUTF8toUTF16(hostName).get()); if (NS_FAILED(rv)) return rv; rv = dialogBlock->SetString(2, PromiseFlatString(textErrorMessage).get()); if (NS_FAILED(rv)) return rv; rv = block->SetISupportAtIndex(1, cert); if (NS_FAILED(rv)) return rv; rv = nsNSSDialogHelper::openDialog(nsnull, "chrome://pippki/content/certerror.xul", block); return rv; }
NS_IMETHODIMP compzillaWindow::HandleEvent (nsIDOMEvent* aDOMEvent) { nsAutoString type; aDOMEvent->GetType (type); if (type.EqualsLiteral ("mousemove")) { OnMouseMove (aDOMEvent); } else if (type.EqualsLiteral ("DOMMouseScroll")) { OnDOMMouseScroll (aDOMEvent); } else if (type.EqualsLiteral ("focus")) { FocusIn (aDOMEvent); } else if (type.EqualsLiteral ("blur")) { FocusOut (aDOMEvent); } else { nsCOMPtr<nsIDOMEventTarget> target; aDOMEvent->GetTarget (getter_AddRefs (target)); SPEW_EVENT ("HandleEvent: Unhandled type=%s, target=%p!!!\n", PromiseFlatString (type).get(), target.get ()); } return NS_OK; }
NS_IMETHODIMP nsJSON::DecodeToJSVal(const nsAString &str, JSContext *cx, jsval *result) { JSAutoRequest ar(cx); JSONParser *parser = JS_BeginJSONParse(cx, result); NS_ENSURE_TRUE(parser, NS_ERROR_UNEXPECTED); JSBool ok = JS_ConsumeJSONText(cx, parser, (jschar*)PromiseFlatString(str).get(), (uint32)str.Length()); // Since we've called JS_BeginJSONParse, we have to call JS_FinishJSONParse, // even if JS_ConsumeJSONText fails. But if either fails, we'll report an // error. ok = ok && JS_FinishJSONParse(cx, parser, JSVAL_NULL); if (!ok) { return NS_ERROR_UNEXPECTED; } return NS_OK; }
XPathExpression* XPathEvaluator::CreateExpression(const nsAString & aExpression, txIParseContext* aContext, nsIDocument* aDocument, ErrorResult& aRv) { if (!mRecycler) { mRecycler = new txResultRecycler; } nsAutoPtr<Expr> expression; aRv = txExprParser::createExpr(PromiseFlatString(aExpression), aContext, getter_Transfers(expression)); if (aRv.Failed()) { if (aRv.ErrorCode() != NS_ERROR_DOM_NAMESPACE_ERR) { aRv.Throw(NS_ERROR_DOM_INVALID_EXPRESSION_ERR); } return nullptr; } return new XPathExpression(Move(expression), mRecycler, aDocument); }
nsresult nsSceneTracker::SetRDFString (nsIRDFDataSource* aDS, nsIRDFResource* aSource, nsIRDFResource* aProp, const nsAString& aString) { NS_ENSURE_ARG(aDS); NS_ENSURE_ARG(aSource); NS_ENSURE_ARG(aProp); nsCOMPtr<nsIRDFNode> tmpnode; nsCOMPtr<nsIRDFService> rdfsvc = do_GetService( "@mozilla.org/rdf/rdf-service;1"); nsCOMPtr<nsIRDFLiteral> newlit; rdfsvc->GetLiteral(PromiseFlatString(aString).get(), getter_AddRefs(newlit)); nsresult rv = aDS->GetTarget(aSource, aProp, PR_TRUE, getter_AddRefs(tmpnode)); if (NS_FAILED(rv)) return rv; if (tmpnode) { // Check if no change is needed nsCOMPtr<nsIRDFLiteral> litval(do_QueryInterface(tmpnode)); if (litval) { PRUnichar* result; rv = litval->GetValue(&result); if (NS_SUCCEEDED(rv)) { if (aString.Equals(result)) { PR_Free(result); return NS_OK; } PR_Free(result); } } rv = aDS->Change(aSource, aProp, tmpnode, newlit); } else if (! aString.IsEmpty()) { rv = aDS->Assert(aSource, aProp, newlit, PR_TRUE); } return rv; }
NS_IMETHODIMP mozSpellChecker::SetCurrentDictionary(const nsAString &aDictionary) { nsresult rv; nsCString *contractId; if (!mDictionariesMap.Get(aDictionary, &contractId)){ NS_WARNING("Dictionary not found"); return NS_ERROR_NOT_AVAILABLE; } if (!mCurrentEngineContractId || !mCurrentEngineContractId->Equals(*contractId)){ mSpellCheckingEngine = do_GetService(contractId->get(), &rv); if (NS_FAILED(rv)) return rv; mCurrentEngineContractId = contractId; } nsresult res; res = mSpellCheckingEngine->SetDictionary(PromiseFlatString(aDictionary).get()); if(NS_FAILED(res)){ NS_WARNING("Dictionary load failed"); return res; } mSpellCheckingEngine->SetPersonalDictionary(mPersonalDictionary); nsXPIDLString language; nsCOMPtr<mozISpellI18NManager> serv(do_GetService("@mozilla.org/spellchecker/i18nmanager;1", &res)); if(serv && NS_SUCCEEDED(res)){ res = serv->GetUtil(language.get(),getter_AddRefs(mConverter)); } return res; }
nsresult nsJSUtils::CompileFunction(JSContext* aCx, JS::Handle<JSObject*> aTarget, JS::CompileOptions& aOptions, const nsACString& aName, uint32_t aArgCount, const char** aArgArray, const nsAString& aBody, JSObject** aFunctionObject) { MOZ_ASSERT(js::GetEnterCompartmentDepth(aCx) > 0); MOZ_ASSERT_IF(aTarget, js::IsObjectInContextCompartment(aTarget, aCx)); MOZ_ASSERT_IF(aOptions.versionSet, aOptions.version != JSVERSION_UNKNOWN); mozilla::DebugOnly<nsIScriptContext*> ctx = GetScriptContextFromJSContext(aCx); MOZ_ASSERT_IF(ctx, ctx->IsContextInitialized()); // Do the junk Gecko is supposed to do before calling into JSAPI. if (aTarget) { JS::ExposeObjectToActiveJS(aTarget); } // Compile. JS::Rooted<JSFunction*> fun(aCx); if (!JS::CompileFunction(aCx, aTarget, aOptions, PromiseFlatCString(aName).get(), aArgCount, aArgArray, PromiseFlatString(aBody).get(), aBody.Length(), &fun)) { ReportPendingException(aCx); return NS_ERROR_FAILURE; } *aFunctionObject = JS_GetFunctionObject(fun); return NS_OK; }