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