/* * Finds the next node in document order of aNode and returns it. * If a node is found, mCurrentNode is set to that node. * @param aNode Node to start search at. * @param aReversed Reverses search to find the preceding node * instead of next. * @param aIndexPos Position of aNode in mPossibleIndexes. * @param _retval Returned node. Null if no node is found * @returns Errorcode */ nsresult nsTreeWalker::NextInDocumentOrderOf(nsINode* aNode, PRBool aReversed, PRInt32 aIndexPos, nsINode** _retval) { nsresult rv; if (!aReversed) { rv = FirstChildOf(aNode, aReversed, aIndexPos+1, _retval); NS_ENSURE_SUCCESS(rv, rv); if (*_retval) return NS_OK; } if (aNode == mRoot){ *_retval = nsnull; return NS_OK; } nsCOMPtr<nsINode> node = aNode; nsCOMPtr<nsINode> currentNodeBackup = mCurrentNode; PRInt16 filtered; PRInt32 childNum; while (1) { // Get our index in the parent nsCOMPtr<nsINode> parent = node->GetNodeParent(); if (!parent) break; childNum = IndexOf(parent, node, aIndexPos); NS_ENSURE_TRUE(childNum >= 0, NS_ERROR_UNEXPECTED); // Search siblings nsCOMPtr<nsINode> sibling; rv = ChildOf(parent, childNum, aReversed, aIndexPos, getter_AddRefs(sibling)); NS_ENSURE_SUCCESS(rv, rv); if (sibling) { if (aReversed) { // in reversed walking we first test if there are // any children. I don't like this piece of code :( nsCOMPtr<nsINode> child = sibling; while (child) { sibling = child; rv = FirstChildOf(sibling, PR_TRUE, aIndexPos, getter_AddRefs(child)); if (NS_FAILED(rv)) { // ChildOf set mCurrentNode and then something // failed. Restore the old value before returning mCurrentNode = currentNodeBackup; mPossibleIndexesPos = -1; return rv; } } } *_retval = sibling; NS_ADDREF(*_retval); return NS_OK; } aIndexPos = aIndexPos < 0 ? -1 : aIndexPos-1; if (aReversed) { // Is parent transparent in filtered view? rv = TestNode(parent, &filtered); NS_ENSURE_SUCCESS(rv, rv); if (filtered == nsIDOMNodeFilter::FILTER_ACCEPT) { mCurrentNode = parent; mPossibleIndexesPos = aIndexPos; *_retval = parent; NS_ADDREF(*_retval); return NS_OK; } } // Is parent the root? if (parent == mRoot) break; node = parent; } *_retval = nsnull; return NS_OK; }
nsresult nsProfileLock::Lock(nsILocalFile* aProfileDir, nsIProfileUnlocker* *aUnlocker) { #if defined (XP_MACOSX) NS_NAMED_LITERAL_STRING(LOCKFILE_NAME, ".parentlock"); NS_NAMED_LITERAL_STRING(OLD_LOCKFILE_NAME, "parent.lock"); #elif defined (XP_UNIX) NS_NAMED_LITERAL_STRING(OLD_LOCKFILE_NAME, "lock"); NS_NAMED_LITERAL_STRING(LOCKFILE_NAME, ".parentlock"); #else NS_NAMED_LITERAL_STRING(LOCKFILE_NAME, "parent.lock"); #endif nsresult rv; if (aUnlocker) *aUnlocker = nsnull; NS_ENSURE_STATE(!mHaveLock); bool isDir; rv = aProfileDir->IsDirectory(&isDir); if (NS_FAILED(rv)) return rv; if (!isDir) return NS_ERROR_FILE_NOT_DIRECTORY; nsCOMPtr<nsILocalFile> lockFile; rv = aProfileDir->Clone((nsIFile **)((void **)getter_AddRefs(lockFile))); if (NS_FAILED(rv)) return rv; rv = lockFile->Append(LOCKFILE_NAME); if (NS_FAILED(rv)) return rv; #if defined(XP_MACOSX) // First, try locking using fcntl. It is more reliable on // a local machine, but may not be supported by an NFS server. nsCAutoString filePath; rv = lockFile->GetNativePath(filePath); if (NS_FAILED(rv)) return rv; rv = LockWithFcntl(filePath); if (NS_FAILED(rv) && (rv != NS_ERROR_FILE_ACCESS_DENIED)) { // If that failed for any reason other than NS_ERROR_FILE_ACCESS_DENIED, // assume we tried an NFS that does not support it. Now, try with symlink. rv = LockWithSymlink(filePath, PR_FALSE); } if (NS_SUCCEEDED(rv)) { // Check for the old-style lock used by pre-mozilla 1.3 builds. // Those builds used an earlier check to prevent the application // from launching if another instance was already running. Because // of that, we don't need to create an old-style lock as well. struct LockProcessInfo { ProcessSerialNumber psn; unsigned long launchDate; }; PRFileDesc *fd = nsnull; PRInt32 ioBytes; ProcessInfoRec processInfo; LockProcessInfo lockProcessInfo; rv = lockFile->SetLeafName(OLD_LOCKFILE_NAME); if (NS_FAILED(rv)) return rv; rv = lockFile->OpenNSPRFileDesc(PR_RDONLY, 0, &fd); if (NS_SUCCEEDED(rv)) { ioBytes = PR_Read(fd, &lockProcessInfo, sizeof(LockProcessInfo)); PR_Close(fd); if (ioBytes == sizeof(LockProcessInfo)) { #ifdef __LP64__ processInfo.processAppRef = NULL; #else processInfo.processAppSpec = NULL; #endif processInfo.processName = NULL; processInfo.processInfoLength = sizeof(ProcessInfoRec); if (::GetProcessInformation(&lockProcessInfo.psn, &processInfo) == noErr && processInfo.processLaunchDate == lockProcessInfo.launchDate) { return NS_ERROR_FILE_ACCESS_DENIED; } } else { NS_WARNING("Could not read lock file - ignoring lock"); } } rv = NS_OK; // Don't propagate error from OpenNSPRFileDesc. } #elif defined(XP_UNIX) nsCAutoString filePath; rv = lockFile->GetNativePath(filePath); if (NS_FAILED(rv)) return rv; // Get the old lockfile name nsCOMPtr<nsIFile> oldLockFile; rv = aProfileDir->Clone(getter_AddRefs(oldLockFile)); if (NS_FAILED(rv)) return rv; rv = oldLockFile->Append(OLD_LOCKFILE_NAME); if (NS_FAILED(rv)) return rv; nsCAutoString oldFilePath; rv = oldLockFile->GetNativePath(oldFilePath); if (NS_FAILED(rv)) return rv; // First, try locking using fcntl. It is more reliable on // a local machine, but may not be supported by an NFS server. rv = LockWithFcntl(filePath); if (NS_SUCCEEDED(rv)) { // Check to see whether there is a symlink lock held by an older // Firefox build, and also place our own symlink lock --- but // mark it "obsolete" so that other newer builds can break the lock // if they obtain the fcntl lock rv = LockWithSymlink(oldFilePath, PR_TRUE); // If the symlink failed for some reason other than it already // exists, then something went wrong e.g. the file system // doesn't support symlinks, or we don't have permission to // create a symlink there. In such cases we should just // continue because it's unlikely there is an old build // running with a symlink there and we've already successfully // placed a fcntl lock. if (rv != NS_ERROR_FILE_ACCESS_DENIED) rv = NS_OK; } else if (rv != NS_ERROR_FILE_ACCESS_DENIED) { // If that failed for any reason other than NS_ERROR_FILE_ACCESS_DENIED, // assume we tried an NFS that does not support it. Now, try with symlink // using the old symlink path rv = LockWithSymlink(oldFilePath, PR_FALSE); } #elif defined(XP_WIN) nsAutoString filePath; rv = lockFile->GetPath(filePath); if (NS_FAILED(rv)) return rv; mLockFileHandle = CreateFileW(filePath.get(), GENERIC_READ | GENERIC_WRITE, 0, // no sharing - of course nsnull, OPEN_ALWAYS, FILE_FLAG_DELETE_ON_CLOSE, nsnull); if (mLockFileHandle == INVALID_HANDLE_VALUE) { // XXXbsmedberg: provide a profile-unlocker here! return NS_ERROR_FILE_ACCESS_DENIED; } #elif defined(XP_OS2) nsCAutoString filePath; rv = lockFile->GetNativePath(filePath); if (NS_FAILED(rv)) return rv; ULONG ulAction = 0; APIRET rc; rc = DosOpen(filePath.get(), &mLockFileHandle, &ulAction, 0, FILE_NORMAL, OPEN_ACTION_CREATE_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS, OPEN_ACCESS_READWRITE | OPEN_SHARE_DENYREADWRITE | OPEN_FLAGS_NOINHERIT, 0 ); if (rc != NO_ERROR) { mLockFileHandle = -1; return NS_ERROR_FILE_ACCESS_DENIED; } #elif defined(VMS) nsCAutoString filePath; rv = lockFile->GetNativePath(filePath); if (NS_FAILED(rv)) return rv; mLockFileDesc = open_noshr(filePath.get(), O_CREAT, 0666); if (mLockFileDesc == -1) { if ((errno == EVMSERR) && (vaxc$errno == RMS$_FLK)) { return NS_ERROR_FILE_ACCESS_DENIED; } else { NS_ERROR("Failed to open lock file."); return NS_ERROR_FAILURE; } } #endif mHaveLock = PR_TRUE; return rv; }
NS_IMETHODIMP HttpChannelChild::AsyncOpen(nsIStreamListener *listener, nsISupports *aContext) { LOG(("HttpChannelChild::AsyncOpen [this=%x uri=%s]\n", this, mSpec.get())); if (mCanceled) return mStatus; NS_ENSURE_TRUE(gNeckoChild != nullptr, NS_ERROR_FAILURE); NS_ENSURE_ARG_POINTER(listener); NS_ENSURE_TRUE(!mIsPending, NS_ERROR_IN_PROGRESS); NS_ENSURE_TRUE(!mWasOpened, NS_ERROR_ALREADY_OPENED); // Port checked in parent, but duplicate here so we can return with error // immediately nsresult rv; rv = NS_CheckPortSafety(mURI); if (NS_FAILED(rv)) return rv; const char *cookieHeader = mRequestHead.PeekHeader(nsHttp::Cookie); if (cookieHeader) { mUserSetCookieHeader = cookieHeader; } AddCookiesToRequest(); // // NOTE: From now on we must return NS_OK; all errors must be handled via // OnStart/OnStopRequest // // notify "http-on-modify-request" observers gHttpHandler->OnModifyRequest(this); mIsPending = true; mWasOpened = true; mListener = listener; mListenerContext = aContext; // add ourselves to the load group. if (mLoadGroup) mLoadGroup->AddRequest(this, nullptr); if (mCanceled) { // We may have been canceled already, either by on-modify-request // listeners or by load group observers; in that case, don't create IPDL // connection. See nsHttpChannel::AsyncOpen(). AsyncAbort(mStatus); return NS_OK; } nsCString appCacheClientId; if (mInheritApplicationCache) { // Pick up an application cache from the notification // callbacks if available nsCOMPtr<nsIApplicationCacheContainer> appCacheContainer; GetCallback(appCacheContainer); if (appCacheContainer) { nsCOMPtr<nsIApplicationCache> appCache; rv = appCacheContainer->GetApplicationCache(getter_AddRefs(appCache)); if (NS_SUCCEEDED(rv) && appCache) { appCache->GetClientID(appCacheClientId); } } } // Get info from nsILoadContext, if any bool haveLoadContext = false; bool isContent = false; bool usePrivateBrowsing = false; bool isInBrowserElement = false; PRUint32 appId = 0; nsCAutoString extendedOrigin; nsCOMPtr<nsILoadContext> loadContext; GetCallback(loadContext); if (loadContext) { haveLoadContext = true; loadContext->GetIsContent(&isContent); loadContext->GetUsePrivateBrowsing(&usePrivateBrowsing); loadContext->GetIsInBrowserElement(&isInBrowserElement); loadContext->GetAppId(&appId); loadContext->GetExtendedOrigin(mURI, extendedOrigin); } // // Send request to the chrome process... // // FIXME: bug 558623: Combine constructor and SendAsyncOpen into one IPC msg mozilla::dom::TabChild* tabChild = nullptr; nsCOMPtr<nsITabChild> iTabChild; GetCallback(iTabChild); if (iTabChild) { tabChild = static_cast<mozilla::dom::TabChild*>(iTabChild.get()); } // The socket transport in the chrome process now holds a logical ref to us // until OnStopRequest, or we do a redirect, or we hit an IPDL error. AddIPDLReference(); gNeckoChild->SendPHttpChannelConstructor(this, tabChild); SendAsyncOpen(IPC::URI(mURI), IPC::URI(mOriginalURI), IPC::URI(mDocumentURI), IPC::URI(mReferrer), mLoadFlags, mClientSetRequestHeaders, mRequestHead.Method(), IPC::InputStream(mUploadStream), mUploadStreamHasHeaders, mPriority, mRedirectionLimit, mAllowPipelining, mForceAllowThirdPartyCookie, mSendResumeAt, mStartPos, mEntityID, mChooseApplicationCache, appCacheClientId, mAllowSpdy, haveLoadContext, isContent, usePrivateBrowsing, isInBrowserElement, appId, extendedOrigin); return NS_OK; }
// // Native method Install // static JSBool InstallTriggerGlobalInstall(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) { nsIDOMInstallTriggerGlobal *nativeThis = getTriggerNative(cx, obj); if (!nativeThis) return JS_FALSE; *rval = JSVAL_FALSE; // make sure XPInstall is enabled, return false if not nsIScriptGlobalObject *globalObject = nsnull; nsIScriptContext *scriptContext = GetScriptContextFromJSContext(cx); if (scriptContext) globalObject = scriptContext->GetGlobalObject(); if (!globalObject) return JS_TRUE; nsCOMPtr<nsIScriptSecurityManager> secman(do_GetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID)); if (!secman) { JS_ReportError(cx, "Could not the script security manager service."); return JS_FALSE; } // get the principal. if it doesn't exist, die. nsCOMPtr<nsIPrincipal> principal; secman->GetSubjectPrincipal(getter_AddRefs(principal)); if (!principal) { JS_ReportError(cx, "Could not get the Subject Principal during InstallTrigger.Install()"); return JS_FALSE; } // get window.location to construct relative URLs nsCOMPtr<nsIURI> baseURL; JSObject* global = JS_GetGlobalObject(cx); if (global) { jsval v; if (JS_GetProperty(cx,global,"location",&v)) { nsAutoString location; ConvertJSValToStr( location, cx, v ); NS_NewURI(getter_AddRefs(baseURL), location); } } PRBool abortLoad = PR_FALSE; // parse associative array of installs if ( argc >= 1 && JSVAL_IS_OBJECT(argv[0]) && JSVAL_TO_OBJECT(argv[0]) ) { nsXPITriggerInfo *trigger = new nsXPITriggerInfo(); if (!trigger) return JS_FALSE; trigger->SetPrincipal(principal); JSIdArray *ida = JS_Enumerate( cx, JSVAL_TO_OBJECT(argv[0]) ); if ( ida ) { jsval v; const PRUnichar *name, *URL; const PRUnichar *iconURL = nsnull; for (int i = 0; i < ida->length && !abortLoad; i++ ) { JS_IdToValue( cx, ida->vector[i], &v ); JSString * str = JS_ValueToString( cx, v ); if (!str) { abortLoad = PR_TRUE; break; } name = reinterpret_cast<const PRUnichar*>(JS_GetStringChars( str )); URL = iconURL = nsnull; JSAutoByteString hash; JS_GetUCProperty( cx, JSVAL_TO_OBJECT(argv[0]), reinterpret_cast<const jschar*>(name), nsCRT::strlen(name), &v ); if ( JSVAL_IS_OBJECT(v) && JSVAL_TO_OBJECT(v) ) { jsval v2; if (JS_GetProperty( cx, JSVAL_TO_OBJECT(v), "URL", &v2 ) && !JSVAL_IS_VOID(v2)) { JSString *str = JS_ValueToString(cx, v2); if (!str) { abortLoad = PR_TRUE; break; } URL = reinterpret_cast<const PRUnichar*>(JS_GetStringChars(str)); } if (JS_GetProperty( cx, JSVAL_TO_OBJECT(v), "IconURL", &v2 ) && !JSVAL_IS_VOID(v2)) { JSString *str = JS_ValueToString(cx, v2); if (!str) { abortLoad = PR_TRUE; break; } iconURL = reinterpret_cast<const PRUnichar*>(JS_GetStringChars(str)); } if (JS_GetProperty( cx, JSVAL_TO_OBJECT(v), "Hash", &v2) && !JSVAL_IS_VOID(v2)) { JSString *str = JS_ValueToString(cx, v2); if (!str || !hash.encode(cx, str)) { abortLoad = PR_TRUE; break; } } } else { JSString *str = JS_ValueToString(cx, v); if (!str) { abortLoad = PR_TRUE; break; } URL = reinterpret_cast<const PRUnichar*>(JS_GetStringChars(str)); } if ( URL ) { // Get relative URL to load nsAutoString xpiURL(URL); if (baseURL) { nsCAutoString resolvedURL; baseURL->Resolve(NS_ConvertUTF16toUTF8(xpiURL), resolvedURL); xpiURL = NS_ConvertUTF8toUTF16(resolvedURL); } nsAutoString icon(iconURL); if (iconURL && baseURL) { nsCAutoString resolvedIcon; baseURL->Resolve(NS_ConvertUTF16toUTF8(icon), resolvedIcon); icon = NS_ConvertUTF8toUTF16(resolvedIcon); } // Make sure we're allowed to load this URL and the icon URL nsresult rv = InstallTriggerCheckLoadURIFromScript(cx, xpiURL); if (NS_FAILED(rv)) abortLoad = PR_TRUE; if (!abortLoad && iconURL) { rv = InstallTriggerCheckLoadURIFromScript(cx, icon); if (NS_FAILED(rv)) abortLoad = PR_TRUE; } if (!abortLoad) { // Add the install item to the trigger collection nsXPITriggerItem *item = new nsXPITriggerItem( name, xpiURL.get(), icon.get(), hash ); if ( item ) { trigger->Add( item ); } else abortLoad = PR_TRUE; } } else abortLoad = PR_TRUE; } JS_DestroyIdArray( cx, ida ); } // pass on only if good stuff found if (!abortLoad && trigger->Size() > 0) { nsCOMPtr<nsIURI> checkuri; nsresult rv = nativeThis->GetOriginatingURI(globalObject, getter_AddRefs(checkuri)); if (NS_SUCCEEDED(rv)) { nsCOMPtr<nsIDOMWindowInternal> win(do_QueryInterface(globalObject)); nsCOMPtr<nsIXPIInstallInfo> installInfo = new nsXPIInstallInfo(win, checkuri, trigger, 0); if (installInfo) { // installInfo now owns triggers PRBool enabled = PR_FALSE; nativeThis->UpdateEnabled(checkuri, XPI_WHITELIST, &enabled); if (!enabled) { nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService(); if (os) os->NotifyObservers(installInfo, "xpinstall-install-blocked", nsnull); } else { // save callback function if any (ignore bad args for now) if ( argc >= 2 && JS_TypeOfValue(cx,argv[1]) == JSTYPE_FUNCTION ) { trigger->SaveCallback( cx, argv[1] ); } PRBool result; nativeThis->StartInstall(installInfo, &result); *rval = BOOLEAN_TO_JSVAL(result); } return JS_TRUE; } } } // didn't pass it on so we must delete trigger delete trigger; } JS_ReportError(cx, "Incorrect arguments to InstallTrigger.Install()"); return JS_FALSE; }
// // Native method StartSoftwareUpdate // static JSBool InstallTriggerGlobalStartSoftwareUpdate(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) { nsIDOMInstallTriggerGlobal *nativeThis = getTriggerNative(cx, obj); if (!nativeThis) return JS_FALSE; PRBool nativeRet; PRInt32 flags = 0; *rval = JSVAL_FALSE; nsIScriptGlobalObject *globalObject = nsnull; nsIScriptContext *scriptContext = GetScriptContextFromJSContext(cx); if (scriptContext) globalObject = scriptContext->GetGlobalObject(); if (!globalObject) return JS_TRUE; // get window.location to construct relative URLs nsCOMPtr<nsIURI> baseURL; JSObject* global = JS_GetGlobalObject(cx); if (global) { jsval v; if (JS_GetProperty(cx,global,"location",&v)) { nsAutoString location; ConvertJSValToStr( location, cx, v ); NS_NewURI(getter_AddRefs(baseURL), location); } } if ( argc >= 1 ) { nsAutoString xpiURL; ConvertJSValToStr(xpiURL, cx, argv[0]); if (baseURL) { nsCAutoString resolvedURL; baseURL->Resolve(NS_ConvertUTF16toUTF8(xpiURL), resolvedURL); xpiURL = NS_ConvertUTF8toUTF16(resolvedURL); } // Make sure caller is allowed to load this url. nsresult rv = InstallTriggerCheckLoadURIFromScript(cx, xpiURL); if (NS_FAILED(rv)) return JS_FALSE; if (argc >= 2 && !JS_ValueToInt32(cx, argv[1], (int32 *)&flags)) { JS_ReportError(cx, "StartSoftwareUpdate() 2nd parameter must be a number"); return JS_FALSE; } nsCOMPtr<nsIURI> checkuri; rv = nativeThis->GetOriginatingURI(globalObject, getter_AddRefs(checkuri)); if (NS_SUCCEEDED(rv)) { nsAutoPtr<nsXPITriggerInfo> trigger(new nsXPITriggerInfo()); nsAutoPtr<nsXPITriggerItem> item(new nsXPITriggerItem(0, xpiURL.get(), nsnull)); if (trigger && item) { // trigger will free item when complete trigger->Add(item.forget()); nsCOMPtr<nsIDOMWindowInternal> win(do_QueryInterface(globalObject)); nsCOMPtr<nsIXPIInstallInfo> installInfo = new nsXPIInstallInfo(win, checkuri, trigger, 0); if (installInfo) { // From here trigger is owned by installInfo until passed on to nsXPInstallManager trigger.forget(); PRBool enabled = PR_FALSE; nativeThis->UpdateEnabled(checkuri, XPI_WHITELIST, &enabled); if (!enabled) { nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService(); if (os) os->NotifyObservers(installInfo, "xpinstall-install-blocked", nsnull); } else { nativeThis->StartInstall(installInfo, &nativeRet); *rval = BOOLEAN_TO_JSVAL(nativeRet); } } } } } else { JS_ReportError(cx, "Function StartSoftwareUpdate requires 1 parameters"); return JS_FALSE; } return JS_TRUE; }
nsresult nsXULPrototypeCache::WritePrototype(nsXULPrototypeDocument* aPrototypeDocument) { nsresult rv = NS_OK, rv2 = NS_OK; // We're here before the FastLoad service has been initialized, probably because // of the profile manager. Bail quietly, don't worry, we'll be back later. if (! gFastLoadService) return NS_OK; // Fetch the current input (if FastLoad file existed) or output (if we're // creating the FastLoad file during this app startup) stream. nsCOMPtr<nsIObjectInputStream> objectInput; nsCOMPtr<nsIObjectOutputStream> objectOutput; gFastLoadService->GetInputStream(getter_AddRefs(objectInput)); gFastLoadService->GetOutputStream(getter_AddRefs(objectOutput)); nsCOMPtr<nsIURI> protoURI = aPrototypeDocument->GetURI(); // Remove this document from the FastLoad table. We use the table's // emptiness instead of a counter to decide when the FastLoad process // has completed. When complete, we can write footer details to the // FastLoad file. RemoveFromFastLoadSet(protoURI); PRInt32 count = mFastLoadURITable.Count(); if (objectOutput) { rv = StartFastLoadingURI(protoURI, nsIFastLoadService::NS_FASTLOAD_WRITE); if (NS_SUCCEEDED(rv)) { // Re-select the URL of the current prototype, as out-of-line script loads // may have changed nsCOMPtr<nsIURI> oldURI; gFastLoadService->SelectMuxedDocument(protoURI, getter_AddRefs(oldURI)); aPrototypeDocument->Write(objectOutput); gFastLoadService->EndMuxedDocument(protoURI); } // If this is the last of one or more XUL master documents loaded // together at app startup, close the FastLoad service's singleton // output stream now. // // NB: we must close input after output, in case the output stream // implementation needs to read from the input stream, to compute a // FastLoad file checksum. In that case, the implementation used // nsIFastLoadFileIO to get the corresponding input stream for this // output stream. if (count == 0) { gFastLoadService->SetOutputStream(nsnull); rv = objectOutput->Close(); if (NS_SUCCEEDED(rv) && gChecksumXULFastLoadFile) { rv = gFastLoadService->CacheChecksum(gFastLoadFile, objectOutput); } } } if (objectInput) { // If this is the last of one or more XUL master documents loaded // together at app startup, close the FastLoad service's singleton // input stream now. if (count == 0) { gFastLoadService->SetInputStream(nsnull); rv2 = objectInput->Close(); } } // If the list is empty now, the FastLoad process is done. if (count == 0) { NS_RELEASE(gFastLoadService); NS_RELEASE(gFastLoadFile); } return NS_FAILED(rv) ? rv : rv2; }
DXGIYCbCrTextureData* IMFYCbCrImage::GetD3D11TextureData(Data aData, gfx::IntSize aSize) { HRESULT hr; RefPtr<ID3D10Multithread> mt; RefPtr<ID3D11Device> device = gfx::DeviceManagerDx::Get()->GetContentDevice(); if (!device) { device = gfx::DeviceManagerDx::Get()->GetCompositorDevice(); } hr = device->QueryInterface((ID3D10Multithread**)getter_AddRefs(mt)); if (FAILED(hr)) { return nullptr; } if (!mt->GetMultithreadProtected()) { return nullptr; } if (!gfx::DeviceManagerDx::Get()->CanInitializeKeyedMutexTextures()) { return nullptr; } if (aData.mYStride < 0 || aData.mCbCrStride < 0) { // D3D11 only supports unsigned stride values. return nullptr; } CD3D11_TEXTURE2D_DESC newDesc(DXGI_FORMAT_R8_UNORM, aData.mYSize.width, aData.mYSize.height, 1, 1); if (device == gfx::DeviceManagerDx::Get()->GetCompositorDevice()) { newDesc.MiscFlags = D3D11_RESOURCE_MISC_SHARED; } else { newDesc.MiscFlags = D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX; } RefPtr<ID3D11Texture2D> textureY; hr = device->CreateTexture2D(&newDesc, nullptr, getter_AddRefs(textureY)); NS_ENSURE_TRUE(SUCCEEDED(hr), nullptr); newDesc.Width = aData.mCbCrSize.width; newDesc.Height = aData.mCbCrSize.height; RefPtr<ID3D11Texture2D> textureCb; hr = device->CreateTexture2D(&newDesc, nullptr, getter_AddRefs(textureCb)); NS_ENSURE_TRUE(SUCCEEDED(hr), nullptr); RefPtr<ID3D11Texture2D> textureCr; hr = device->CreateTexture2D(&newDesc, nullptr, getter_AddRefs(textureCr)); NS_ENSURE_TRUE(SUCCEEDED(hr), nullptr); // The documentation here seems to suggest using the immediate mode context // on more than one thread is not allowed: // https://msdn.microsoft.com/en-us/library/windows/desktop/ff476891(v=vs.85).aspx // The Debug Layer seems to imply it is though. When the ID3D10Multithread // layer is on. The Enter/Leave of the critical section shouldn't even be // required but were added for extra security. { AutoLockD3D11Texture lockY(textureY); AutoLockD3D11Texture lockCr(textureCr); AutoLockD3D11Texture lockCb(textureCb); D3D11MTAutoEnter mtAutoEnter(mt.forget()); RefPtr<ID3D11DeviceContext> ctx; device->GetImmediateContext((ID3D11DeviceContext**)getter_AddRefs(ctx)); D3D11_BOX box; box.front = box.top = box.left = 0; box.back = 1; box.right = aData.mYSize.width; box.bottom = aData.mYSize.height; ctx->UpdateSubresource(textureY, 0, &box, aData.mYChannel, aData.mYStride, 0); box.right = aData.mCbCrSize.width; box.bottom = aData.mCbCrSize.height; ctx->UpdateSubresource(textureCb, 0, &box, aData.mCbChannel, aData.mCbCrStride, 0); ctx->UpdateSubresource(textureCr, 0, &box, aData.mCrChannel, aData.mCbCrStride, 0); } return DXGIYCbCrTextureData::Create(textureY, textureCb, textureCr, aSize, aData.mYSize, aData.mCbCrSize); }
nsresult nsXFormsContextContainer::HandleFocus(nsIDOMEvent *aEvent) { if (!aEvent || !mElement) return NS_OK; if (!nsXFormsUtils::EventHandlingAllowed(aEvent, mElement)) return NS_OK; // Need to explicitly create the parent chain. This ensures that this code // works both in 1.8, which has the old event dispatching code, and also in // the later versions of Gecko with the new event dispatching. // See also Bug 331081. nsCOMPtr<nsIDOMNSEvent> event = do_QueryInterface(aEvent); NS_ENSURE_STATE(event); nsCOMPtr<nsIDOMEventTarget> target; event->GetOriginalTarget(getter_AddRefs(target)); nsCOMPtr<nsIDOMNode> currentNode = do_QueryInterface(target); nsCOMArray<nsIDOMNode> containerStack(4); while (currentNode) { nsCOMPtr<nsIXFormsRepeatItemElement> repeatItem = do_QueryInterface(currentNode); if (repeatItem) { containerStack.AppendObject(currentNode); } nsCOMPtr<nsIDOMNode> parent; currentNode->GetParentNode(getter_AddRefs(parent)); currentNode.swap(parent); } for (PRInt32 i = containerStack.Count() - 1; i >= 0; --i) { nsCOMPtr<nsIDOMNode> node = containerStack[i]; if (node) { // Either we, or an element we contain, has gotten focus, so we need to // set the repeat index. This is done through the <repeat> the // nsXFormsContextContainer belongs to. // // Start by finding the <repeat> (our grandparent): // <repeat> <-- gParent // <div> // <contextcontainer\> <-- this // </div> // </repeat> nsCOMPtr<nsIDOMNode> parent; node->GetParentNode(getter_AddRefs(parent)); if (parent) { nsCOMPtr<nsIDOMNode> grandParent; parent->GetParentNode(getter_AddRefs(grandParent)); nsCOMPtr<nsIXFormsRepeatElement> repeat = do_QueryInterface(grandParent); nsCOMPtr<nsIXFormsRepeatItemElement> repeatItem = do_QueryInterface(node); if (repeat && repeatItem) { PRInt32 position = 1; repeatItem->GetContextPosition(&position); // Tell <repeat> about the new index position PRUint32 tmp = position; repeat->SetIndex(&tmp, PR_FALSE); } } } } return NS_OK; }
JSObject * WrapperFactory::PrepareForWrapping(JSContext *cx, JSObject *scope, JSObject *obj, uintN flags) { // Don't unwrap an outer window, just double wrap it if needed. if (obj->getClass()->ext.innerObject) return DoubleWrap(cx, obj, flags); // Here are the rules for wrapping: // We should never get a proxy here (the JS engine unwraps those for us). JS_ASSERT(!obj->isWrapper()); // As soon as an object is wrapped in a security wrapper, it morphs to be // a fat wrapper. (see also: bug XXX). if (IS_SLIM_WRAPPER(obj) && !MorphSlimWrapper(cx, obj)) return nsnull; // We only hand out outer objects to script. obj = GetCurrentOuter(cx, obj); if (obj->getClass()->ext.innerObject) return DoubleWrap(cx, obj, flags); // Now, our object is ready to be wrapped, but several objects (notably // nsJSIIDs) have a wrapper per scope. If we are about to wrap one of // those objects in a security wrapper, then we need to hand back the // wrapper for the new scope instead. Also, global objects don't move // between scopes so for those we also want to return the wrapper. So... if (!IS_WN_WRAPPER(obj) || !obj->getParent()) return DoubleWrap(cx, obj, flags); XPCWrappedNative *wn = static_cast<XPCWrappedNative *>(xpc_GetJSPrivate(obj)); // If the object doesn't have classinfo we want to return the same // XPCWrappedNative so that we keep the same set of interfaces. if (!wn->GetClassInfo()) return DoubleWrap(cx, obj, flags); JSAutoEnterCompartment ac; if (!ac.enter(cx, obj)) return nsnull; XPCCallContext ccx(JS_CALLER, cx, obj); { if (NATIVE_HAS_FLAG(&ccx, WantPreCreate)) { // We have a precreate hook. This object might enforce that we only // ever create JS object for it. JSObject *originalScope = scope; nsresult rv = wn->GetScriptableInfo()->GetCallback()-> PreCreate(wn->Native(), cx, scope, &scope); NS_ENSURE_SUCCESS(rv, DoubleWrap(cx, obj, flags)); // If the handed back scope differs from the passed-in scope and is in // a separate compartment, then this object is explicitly requesting // that we don't create a second JS object for it: create a security // wrapper. if (originalScope->compartment() != scope->getCompartment()) return DoubleWrap(cx, obj, flags); // Note: this penalizes objects that only have one wrapper, but are // being accessed across compartments. We would really prefer to // replace the above code with a test that says "do you only have one // wrapper?" } } // NB: Passing a holder here inhibits slim wrappers under // WrapNativeToJSVal. nsCOMPtr<nsIXPConnectJSObjectHolder> holder; // This public WrapNativeToJSVal API enters the compartment of 'scope' // so we don't have to. jsval v; nsresult rv = nsXPConnect::FastGetXPConnect()->WrapNativeToJSVal(cx, scope, wn->Native(), nsnull, &NS_GET_IID(nsISupports), PR_FALSE, &v, getter_AddRefs(holder)); if (NS_SUCCEEDED(rv)) { obj = JSVAL_TO_OBJECT(v); NS_ASSERTION(IS_WN_WRAPPER(obj), "bad object"); XPCWrappedNative *newwn = static_cast<XPCWrappedNative *>(xpc_GetJSPrivate(obj)); if (newwn->GetSet()->GetInterfaceCount() < wn->GetSet()->GetInterfaceCount()) newwn->SetSet(wn->GetSet()); } return DoubleWrap(cx, obj, flags); }
/* readonly attribute AString associatedLink; */ NS_IMETHODIMP nsContextMenuInfo::GetAssociatedLink(nsAString& aHRef) { NS_ENSURE_STATE(mAssociatedLink); aHRef.Truncate(0); nsCOMPtr<nsIDOMElement> content(do_QueryInterface(mAssociatedLink)); nsAutoString localName; if (content) content->GetLocalName(localName); nsCOMPtr<nsIDOMElement> linkContent; ToLowerCase(localName); if (localName.EqualsLiteral("a") || localName.EqualsLiteral("area") || localName.EqualsLiteral("link")) { bool hasAttr; content->HasAttribute(NS_LITERAL_STRING("href"), &hasAttr); if (hasAttr) { linkContent = content; nsCOMPtr<nsIDOMHTMLAnchorElement> anchor(do_QueryInterface(linkContent)); if (anchor) anchor->GetHref(aHRef); else { nsCOMPtr<nsIDOMHTMLAreaElement> area(do_QueryInterface(linkContent)); if (area) area->GetHref(aHRef); else { nsCOMPtr<nsIDOMHTMLLinkElement> link(do_QueryInterface(linkContent)); if (link) link->GetHref(aHRef); } } } } else { nsCOMPtr<nsIDOMNode> curr; mAssociatedLink->GetParentNode(getter_AddRefs(curr)); while (curr) { content = do_QueryInterface(curr); if (!content) break; content->GetLocalName(localName); ToLowerCase(localName); if (localName.EqualsLiteral("a")) { bool hasAttr; content->HasAttribute(NS_LITERAL_STRING("href"), &hasAttr); if (hasAttr) { linkContent = content; nsCOMPtr<nsIDOMHTMLAnchorElement> anchor(do_QueryInterface(linkContent)); if (anchor) anchor->GetHref(aHRef); } else linkContent = nullptr; // Links can't be nested. break; } nsCOMPtr<nsIDOMNode> temp = curr; temp->GetParentNode(getter_AddRefs(curr)); } } return NS_OK; }
nsresult nsFontCache::GetMetricsFor(const nsFont& aFont, nsIAtom* aLangGroup, nsIFontMetrics *&aMetrics) { // First check our cache // start from the end, which is where we put the most-recent-used element nsIFontMetrics* fm; PRInt32 n = mFontMetrics.Count() - 1; for (PRInt32 i = n; i >= 0; --i) { fm = static_cast<nsIFontMetrics*>(mFontMetrics[i]); if (fm->Font().Equals(aFont)) { nsCOMPtr<nsIAtom> langGroup; fm->GetLangGroup(getter_AddRefs(langGroup)); if (aLangGroup == langGroup.get()) { if (i != n) { // promote it to the end of the cache mFontMetrics.MoveElement(i, n); } NS_ADDREF(aMetrics = fm); return NS_OK; } } } // It's not in the cache. Get font metrics and then cache them. aMetrics = nsnull; nsresult rv = CreateFontMetricsInstance(&fm); if (NS_FAILED(rv)) return rv; rv = fm->Init(aFont, aLangGroup, mContext); if (NS_SUCCEEDED(rv)) { // the mFontMetrics list has the "head" at the end, because append is // cheaper than insert mFontMetrics.AppendElement(fm); aMetrics = fm; NS_ADDREF(aMetrics); return NS_OK; } fm->Destroy(); NS_RELEASE(fm); // One reason why Init() fails is because the system is running out of resources. // e.g., on Win95/98 only a very limited number of GDI objects are available. // Compact the cache and try again. Compact(); rv = CreateFontMetricsInstance(&fm); if (NS_FAILED(rv)) return rv; rv = fm->Init(aFont, aLangGroup, mContext); if (NS_SUCCEEDED(rv)) { mFontMetrics.AppendElement(fm); aMetrics = fm; NS_ADDREF(aMetrics); return NS_OK; } fm->Destroy(); NS_RELEASE(fm); // could not setup a new one, send an old one (XXX search a "best match"?) n = mFontMetrics.Count() - 1; // could have changed in Compact() if (n >= 0) { aMetrics = static_cast<nsIFontMetrics*>(mFontMetrics[n]); NS_ADDREF(aMetrics); return NS_OK; } NS_POSTCONDITION(NS_SUCCEEDED(rv), "font metrics should not be null - bug 136248"); return rv; }
nsresult nsContextMenuInfo::GetBackgroundImageRequestInternal(nsIDOMNode *aDOMNode, imgRequestProxy **aRequest) { NS_ENSURE_ARG_POINTER(aDOMNode); nsCOMPtr<nsIDOMNode> domNode = aDOMNode; nsCOMPtr<nsIDOMNode> parentNode; nsCOMPtr<nsIDOMDocument> document; domNode->GetOwnerDocument(getter_AddRefs(document)); NS_ENSURE_TRUE(document, NS_ERROR_FAILURE); nsCOMPtr<nsIDOMWindow> window; document->GetDefaultView(getter_AddRefs(window)); NS_ENSURE_TRUE(window, NS_ERROR_FAILURE); nsCOMPtr<nsIDOMCSSPrimitiveValue> primitiveValue; nsAutoString bgStringValue; // get Content Security Policy to pass to LoadImage nsCOMPtr<nsIDocument> doc(do_QueryInterface(document)); nsCOMPtr<nsIPrincipal> principal; nsCOMPtr<nsIChannelPolicy> channelPolicy; nsCOMPtr<nsIContentSecurityPolicy> csp; if (doc) { principal = doc->NodePrincipal(); nsresult rv = principal->GetCsp(getter_AddRefs(csp)); NS_ENSURE_SUCCESS(rv, rv); if (csp) { channelPolicy = do_CreateInstance("@mozilla.org/nschannelpolicy;1"); channelPolicy->SetContentSecurityPolicy(csp); channelPolicy->SetLoadType(nsIContentPolicy::TYPE_IMAGE); } } while (true) { nsCOMPtr<nsIDOMElement> domElement(do_QueryInterface(domNode)); // bail for the parent node of the root element or null argument if (!domElement) break; nsCOMPtr<nsIDOMCSSStyleDeclaration> computedStyle; window->GetComputedStyle(domElement, EmptyString(), getter_AddRefs(computedStyle)); if (computedStyle) { nsCOMPtr<nsIDOMCSSValue> cssValue; computedStyle->GetPropertyCSSValue(NS_LITERAL_STRING("background-image"), getter_AddRefs(cssValue)); primitiveValue = do_QueryInterface(cssValue); if (primitiveValue) { primitiveValue->GetStringValue(bgStringValue); if (!bgStringValue.EqualsLiteral("none")) { nsCOMPtr<nsIURI> bgUri; NS_NewURI(getter_AddRefs(bgUri), bgStringValue); NS_ENSURE_TRUE(bgUri, NS_ERROR_FAILURE); nsRefPtr<imgLoader> il = imgLoader::GetInstance(); NS_ENSURE_TRUE(il, NS_ERROR_FAILURE); return il->LoadImage(bgUri, nullptr, nullptr, principal, nullptr, nullptr, nullptr, nsIRequest::LOAD_NORMAL, nullptr, channelPolicy, EmptyString(), aRequest); } } // bail if we encounter non-transparent background-color computedStyle->GetPropertyCSSValue(NS_LITERAL_STRING("background-color"), getter_AddRefs(cssValue)); primitiveValue = do_QueryInterface(cssValue); if (primitiveValue) { primitiveValue->GetStringValue(bgStringValue); if (!bgStringValue.EqualsLiteral("transparent")) return NS_ERROR_FAILURE; } } domNode->GetParentNode(getter_AddRefs(parentNode)); domNode = parentNode; } return NS_ERROR_FAILURE; }
HRESULT nsEventSink::InternalInvoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr) { FUNCDESC *pFuncDesc = NULL; HRESULT hr = S_OK; CComBSTR bstrName; // Must search and compare each member to the dispid... if (m_spEventSinkTypeInfo) { HRESULT hr = S_OK; TYPEATTR* pAttr; hr = m_spEventSinkTypeInfo->GetTypeAttr(&pAttr); if (pAttr) { int i; for (i = 0; i < pAttr->cFuncs; i++) { hr = m_spEventSinkTypeInfo->GetFuncDesc(i, &pFuncDesc); if (FAILED(hr)) return hr; if (pFuncDesc->memid == dispIdMember) { UINT cNames = 0; m_spEventSinkTypeInfo->GetNames(dispIdMember, &bstrName, 1, &cNames); break; } m_spEventSinkTypeInfo->ReleaseFuncDesc(pFuncDesc); pFuncDesc = NULL; } m_spEventSinkTypeInfo->ReleaseTypeAttr(pAttr); } } if (!pFuncDesc) { // Return return S_OK; } #ifdef DEBUG { // Dump out some info to look at ATLTRACE(_T("Invoke(%d)\n"), (int) dispIdMember); ATLTRACE(_T(" ")); /* Return code */ switch (pFuncDesc->elemdescFunc.tdesc.vt) { case VT_HRESULT: ATLTRACE(_T("HRESULT")); break; case VT_VOID: ATLTRACE(_T("void")); break; default: ATLTRACE(_T("void /* vt = %d */"), pFuncDesc->elemdescFunc.tdesc.vt); break; } /* Function name */ ATLTRACE(_T(" %S("), SUCCEEDED(hr) ? bstrName.m_str : L"?unknown?"); /* Parameters */ for (int i = 0; i < pFuncDesc->cParams; i++) { USHORT paramFlags = pFuncDesc->lprgelemdescParam[i].paramdesc.wParamFlags; ATLTRACE("["); BOOL addComma = FALSE; if (paramFlags & PARAMFLAG_FIN) { ATLTRACE(_T("in")); addComma = TRUE; } if (paramFlags & PARAMFLAG_FOUT) { ATLTRACE(addComma ? _T(",out") : _T("out")); addComma = TRUE; } if (paramFlags & PARAMFLAG_FRETVAL) { ATLTRACE(addComma ? _T(",retval") : _T("retval")); addComma = TRUE; } ATLTRACE("] "); VARTYPE vt = pFuncDesc->lprgelemdescParam[i].tdesc.vt; switch (vt) { case VT_HRESULT: ATLTRACE(_T("HRESULT")); break; case VT_VARIANT: ATLTRACE(_T("VARIANT")); break; case VT_I2: ATLTRACE(_T("short")); break; case VT_I4: ATLTRACE(_T("long")); break; case VT_R8: ATLTRACE(_T("double")); break; case VT_BOOL: ATLTRACE(_T("VARIANT_BOOL")); break; case VT_BSTR: ATLTRACE(_T("BSTR")); break; case VT_DISPATCH: ATLTRACE(_T("IDispatch *")); break; case VT_UNKNOWN: ATLTRACE(_T("IUnknown *")); break; case VT_USERDEFINED: ATLTRACE(_T("/* Userdefined */")); break; case VT_PTR: ATLTRACE(_T("void *")); break; case VT_VOID: ATLTRACE(_T("void")); break; // More could be added... default: ATLTRACE(_T("/* vt = %d */"), vt); break; } if (i + 1 < pFuncDesc->cParams) { ATLTRACE(_T(", ")); } } ATLTRACE(_T(");\n")); } #endif m_spEventSinkTypeInfo->ReleaseFuncDesc(pFuncDesc); pFuncDesc = NULL; nsCOMPtr<nsIDOMElement> element; NPN_GetValue(mPlugin->pPluginInstance, NPNVDOMElement, static_cast<nsIDOMElement **>(getter_AddRefs(element))); if (!element) { NS_ERROR("can't get the object element"); return S_OK; } nsAutoString id; if (NS_FAILED(element->GetAttribute(NS_LITERAL_STRING("id"), id)) || id.IsEmpty()) { // Object has no name so it can't fire events return S_OK; } nsDependentString eventName(bstrName.m_str); // Fire the script event handler... nsCOMPtr<nsIDOMWindow> window; NPN_GetValue(mPlugin->pPluginInstance, NPNVDOMWindow, static_cast<nsIDOMWindow **>(getter_AddRefs(window))); nsCOMPtr<nsIScriptEventManager> eventManager(do_GetInterface(window)); if (!eventManager) return S_OK; nsCOMPtr<nsISupports> handler; eventManager->FindEventHandler(id, eventName, pDispParams->cArgs, getter_AddRefs(handler)); if (!handler) { return S_OK; } // Create a list of arguments to pass along // // This array is created on the stack if the number of arguments // less than kMaxArgsOnStack. Otherwise, the array is heap // allocated. // const int kMaxArgsOnStack = 10; PRUint32 argc = pDispParams->cArgs; jsval *args = nsnull; jsval stackArgs[kMaxArgsOnStack]; // Heap allocate the jsval array if it is too big to fit on // the stack (ie. more than kMaxArgsOnStack arguments) if (argc > kMaxArgsOnStack) { args = new jsval[argc]; if (!args) return S_OK; } else if (argc) { // Use the jsval array on the stack... args = stackArgs; } if (argc) { nsCOMPtr<nsIDispatchSupport> disp(do_GetService("@mozilla.org/nsdispatchsupport;1")); for (UINT i = 0; i < argc; i++) { // Arguments are listed backwards, intentionally, in rgvarg disp->COMVariant2JSVal(&pDispParams->rgvarg[argc - 1 - i], &args[i]); } } // Fire the Event. eventManager->InvokeEventHandler(handler, element, args, argc); // Free the jsvals if they were heap allocated... if (args != stackArgs) { delete [] args; } // TODO Turn js objects for out params back into VARIANTS // TODO Turn js return code into VARIANT // TODO handle js exception and fill in exception info (do we care?) if (pExcepInfo) { pExcepInfo->wCode = 0; } return S_OK; }
HRESULT nsScriptablePeer::ConvertVariants(VARIANT *aIn, nsIVariant **aOut) { if (aIn == NULL || aOut == NULL) { return NS_ERROR_INVALID_ARG; } *aOut = nsnull; nsresult rv; nsCOMPtr<nsIWritableVariant> v = do_CreateInstance("@mozilla.org/variant;1", &rv); // NOTE: THIS IS AN UGLY BACKWARDS COMPATIBILITY HACK TO WORKAROUND // XPCOM GLUE'S INABILITY TO FIND A CERTAIN ENTRY POINT IN MOZ1.0.x/NS7.0! // DO NOT TAUNT THE HACK if (NS_FAILED(rv)) { // do_CreateInstance macro is broken so load the component manager by // hand and get it to create the component. HMODULE hlib = ::LoadLibrary("xpcom.dll"); if (hlib) { nsIComponentManager *pManager = nsnull; // A frozen interface, even in 1.0.x typedef nsresult (PR_CALLBACK *Moz1XGetComponentManagerFunc)(nsIComponentManager* *result); Moz1XGetComponentManagerFunc compMgr = (Moz1XGetComponentManagerFunc) ::GetProcAddress(hlib, "NS_GetComponentManager"); if (compMgr) { compMgr(&pManager); if (pManager) { rv = pManager->CreateInstanceByContractID("@mozilla.org/variant;1", nsnull, NS_GET_IID(nsIWritableVariant), getter_AddRefs(v)); pManager->Release(); } } ::FreeLibrary(hlib); } } // END HACK NS_ENSURE_SUCCESS(rv, rv); switch (aIn->vt) { case VT_EMPTY: v->SetAsEmpty(); break; case VT_BSTR: v->SetAsWString(aIn->bstrVal); break; case VT_I1: v->SetAsInt8(aIn->cVal); break; case VT_I2: v->SetAsInt16(aIn->iVal); break; case VT_I4: v->SetAsInt32(aIn->lVal); break; case VT_UI1: v->SetAsUint8(aIn->bVal); break; case VT_UI2: v->SetAsUint16(aIn->uiVal); break; case VT_UI4: v->SetAsUint32(aIn->ulVal); break; case VT_BOOL: v->SetAsBool(aIn->boolVal == VARIANT_TRUE ? PR_TRUE : PR_FALSE); break; case VT_R4: v->SetAsFloat(aIn->fltVal); break; case VT_R8: v->SetAsDouble(aIn->dblVal); break; } *aOut = v; NS_ADDREF(*aOut); return NS_OK; }
nsresult sbLocalDatabaseLibraryFactory::InitalizeLibrary(nsIFile* aDatabaseFile, const nsAString &aResourceGUID) { nsresult rv; PRInt32 dbOk; nsCOMPtr<nsIFile> parentDirectory; rv = aDatabaseFile->GetParent(getter_AddRefs(parentDirectory)); NS_ENSURE_SUCCESS(rv, rv); bool parentExists; rv = parentDirectory->Exists(&parentExists); NS_ENSURE_SUCCESS(rv, rv); if (!parentExists) { rv = CreateDirectory(parentDirectory); NS_ENSURE_SUCCESS(rv, rv); } bool parentIsWritable = IsDirectoryWritable(parentDirectory); NS_ENSURE_TRUE(parentIsWritable, NS_ERROR_FILE_ACCESS_DENIED); // Now that we know we have appropriate permissions make a new query. nsCOMPtr<sbIDatabaseQuery> query = do_CreateInstance(SONGBIRD_DATABASEQUERY_CONTRACTID, &rv); NS_ENSURE_SUCCESS(rv, rv); rv = query->SetAsyncQuery(PR_FALSE); NS_ENSURE_SUCCESS(rv, rv); rv = SetQueryDatabaseFile(query, aDatabaseFile); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIURI> schemaURI; rv = NS_NewURI(getter_AddRefs(schemaURI), NS_LITERAL_CSTRING(SCHEMA_URL)); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIInputStream> input; rv = NS_OpenURI(getter_AddRefs(input), schemaURI); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIConverterInputStream> converterStream = do_CreateInstance("@mozilla.org/intl/converter-input-stream;1", &rv); NS_ENSURE_SUCCESS(rv, rv); rv = converterStream->Init(input, "UTF-8", CONVERTER_BUFFER_SIZE, nsIConverterInputStream:: DEFAULT_REPLACEMENT_CHARACTER); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIUnicharInputStream> unichar = do_QueryInterface(converterStream, &rv); NS_ENSURE_SUCCESS(rv, rv); PRUint32 read; nsString response, result; rv = unichar->ReadString(PR_UINT32_MAX, result, &read); NS_ENSURE_SUCCESS(rv, rv); NS_ASSERTION(read, "Schema file zero bytes?"); while (read > 0) { response.Append(result); rv = unichar->ReadString(PR_UINT32_MAX, result, &read); NS_ENSURE_SUCCESS(rv, rv); } rv = unichar->Close(); NS_ENSURE_SUCCESS(rv, rv); NS_NAMED_LITERAL_STRING(colonNewline, ";\n"); PRInt32 posStart = 0; PRInt32 posEnd = response.Find(colonNewline, posStart); while (posEnd >= 0) { rv = query->AddQuery(Substring(response, posStart, posEnd - posStart)); NS_ENSURE_SUCCESS(rv, rv); posStart = posEnd + 2; posEnd = response.Find(colonNewline, posStart); } rv = query->Execute(&dbOk); NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_TRUE(dbOk == 0, NS_ERROR_FAILURE); nsString guid(aResourceGUID); if(guid.IsEmpty()) { // Create a resource guid for this database. nsCOMPtr<nsIUUIDGenerator> uuidGen = do_GetService("@mozilla.org/uuid-generator;1", &rv); NS_ENSURE_SUCCESS(rv, rv); nsID id; rv = uuidGen->GenerateUUIDInPlace(&id); NS_ENSURE_SUCCESS(rv, rv); char guidChars[NSID_LENGTH]; id.ToProvidedString(guidChars); guid = NS_ConvertASCIItoUTF16(nsDependentCString(guidChars + 1, NSID_LENGTH - 3)); } // Insert the guid into the database. nsCOMPtr<sbISQLInsertBuilder> insert = do_CreateInstance(SB_SQLBUILDER_INSERT_CONTRACTID, &rv); NS_ENSURE_SUCCESS(rv, rv); rv = insert->SetIntoTableName(NS_LITERAL_STRING("library_metadata")); NS_ENSURE_SUCCESS(rv, rv); rv = insert->AddColumn(NS_LITERAL_STRING("name")); NS_ENSURE_SUCCESS(rv, rv); rv = insert->AddColumn(NS_LITERAL_STRING("value")); NS_ENSURE_SUCCESS(rv, rv); rv = insert->AddValueString(NS_LITERAL_STRING("resource-guid")); NS_ENSURE_SUCCESS(rv, rv); rv = insert->AddValueString(guid); NS_ENSURE_SUCCESS(rv, rv); nsAutoString sql; rv = insert->ToString(sql); NS_ENSURE_SUCCESS(rv, rv); rv = query->ResetQuery(); NS_ENSURE_SUCCESS(rv, rv); rv = query->AddQuery(sql); NS_ENSURE_SUCCESS(rv, rv); rv = query->Execute(&dbOk); NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_TRUE(dbOk == 0, NS_ERROR_FAILURE); nsString now; sbLocalDatabaseLibrary::GetNowString(now); nsCOMPtr<nsIURI> fileURI; rv = NS_NewFileURI(getter_AddRefs(fileURI), aDatabaseFile); NS_ENSURE_SUCCESS(rv, rv); nsCString uriSpec; rv = fileURI->GetSpec(uriSpec); NS_ENSURE_SUCCESS(rv, rv); // Add the default library media item properties insert = do_CreateInstance(SB_SQLBUILDER_INSERT_CONTRACTID, &rv); NS_ENSURE_SUCCESS(rv, rv); rv = insert->SetIntoTableName(NS_LITERAL_STRING("library_media_item")); NS_ENSURE_SUCCESS(rv, rv); rv = insert->AddColumn(NS_LITERAL_STRING("guid")); NS_ENSURE_SUCCESS(rv, rv); rv = insert->AddValueString(guid); NS_ENSURE_SUCCESS(rv, rv); rv = insert->AddColumn(NS_LITERAL_STRING("created")); NS_ENSURE_SUCCESS(rv, rv); rv = insert->AddValueString(now); NS_ENSURE_SUCCESS(rv, rv); rv = insert->AddColumn(NS_LITERAL_STRING("updated")); NS_ENSURE_SUCCESS(rv, rv); rv = insert->AddValueString(now); NS_ENSURE_SUCCESS(rv, rv); rv = insert->AddColumn(NS_LITERAL_STRING("content_url")); NS_ENSURE_SUCCESS(rv, rv); rv = insert->AddValueString(NS_ConvertUTF8toUTF16(uriSpec)); NS_ENSURE_SUCCESS(rv, rv); rv = insert->AddColumn(NS_LITERAL_STRING("hidden")); NS_ENSURE_SUCCESS(rv, rv); rv = insert->AddValueLong(0); NS_ENSURE_SUCCESS(rv, rv); rv = insert->AddColumn(NS_LITERAL_STRING("is_list")); NS_ENSURE_SUCCESS(rv, rv); rv = insert->AddValueLong(0); NS_ENSURE_SUCCESS(rv, rv); rv = insert->ToString(sql); NS_ENSURE_SUCCESS(rv, rv); rv = query->ResetQuery(); NS_ENSURE_SUCCESS(rv, rv); rv = query->AddQuery(sql); NS_ENSURE_SUCCESS(rv, rv); rv = query->Execute(&dbOk); NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_TRUE(dbOk == 0, NS_ERROR_FAILURE); return NS_OK; }
nsresult nsMsgSearchOfflineMail::ConstructExpressionTree(nsISupportsArray * termList, uint32_t termCount, uint32_t &aStartPosInList, nsMsgSearchBoolExpression ** aExpressionTree) { nsMsgSearchBoolExpression * finalExpression = *aExpressionTree; if (!finalExpression) finalExpression = new nsMsgSearchBoolExpression(); while (aStartPosInList < termCount) { nsCOMPtr<nsIMsgSearchTerm> pTerm; termList->QueryElementAt(aStartPosInList, NS_GET_IID(nsIMsgSearchTerm), (void **)getter_AddRefs(pTerm)); NS_ASSERTION (pTerm, "couldn't get term to match"); bool beginsGrouping; bool endsGrouping; pTerm->GetBeginsGrouping(&beginsGrouping); pTerm->GetEndsGrouping(&endsGrouping); if (beginsGrouping) { //temporarily turn off the grouping for our recursive call pTerm->SetBeginsGrouping(false); nsMsgSearchBoolExpression * innerExpression = new nsMsgSearchBoolExpression(); // the first search term in the grouping is the one that holds the operator for how this search term // should be joined with the expressions to it's left. bool booleanAnd; pTerm->GetBooleanAnd(&booleanAnd); // now add this expression tree to our overall expression tree... finalExpression = nsMsgSearchBoolExpression::AddExpressionTree(finalExpression, innerExpression, booleanAnd); // recursively process this inner expression ConstructExpressionTree(termList, termCount, aStartPosInList, &finalExpression->m_rightChild); // undo our damage pTerm->SetBeginsGrouping(true); } else { finalExpression = nsMsgSearchBoolExpression::AddSearchTerm(finalExpression, pTerm, nullptr); // add the term to the expression tree if (endsGrouping) break; } aStartPosInList++; } // while we still have terms to process in this group *aExpressionTree = finalExpression; return NS_OK; }
void nsXULPrototypeCache::AbortFastLoads() { #ifdef DEBUG_brendan NS_BREAK(); #endif // Save a strong ref to the FastLoad file, so we can remove it after we // close open streams to it. nsCOMPtr<nsIFile> file = gFastLoadFile; // Flush the XUL cache for good measure, in case we cached a bogus/downrev // script, somehow. Flush(); // Clear the FastLoad set mFastLoadURITable.Clear(); if (! gFastLoadService) return; // Fetch the current input (if FastLoad file existed) or output (if we're // creating the FastLoad file during this app startup) stream. nsCOMPtr<nsIObjectInputStream> objectInput; nsCOMPtr<nsIObjectOutputStream> objectOutput; gFastLoadService->GetInputStream(getter_AddRefs(objectInput)); gFastLoadService->GetOutputStream(getter_AddRefs(objectOutput)); if (objectOutput) { gFastLoadService->SetOutputStream(nsnull); if (NS_SUCCEEDED(objectOutput->Close()) && gChecksumXULFastLoadFile) gFastLoadService->CacheChecksum(gFastLoadFile, objectOutput); } if (objectInput) { // If this is the last of one or more XUL master documents loaded // together at app startup, close the FastLoad service's singleton // input stream now. gFastLoadService->SetInputStream(nsnull); objectInput->Close(); } // Now rename or remove the file. if (file) { #ifdef DEBUG // Remove any existing Aborted.mfasl files generated in previous runs. nsCOMPtr<nsIFile> existingAbortedFile; file->Clone(getter_AddRefs(existingAbortedFile)); if (existingAbortedFile) { existingAbortedFile->SetLeafName(NS_LITERAL_STRING("Aborted.mfasl")); PRBool fileExists = PR_FALSE; existingAbortedFile->Exists(&fileExists); if (fileExists) existingAbortedFile->Remove(PR_FALSE); } file->MoveToNative(nsnull, NS_LITERAL_CSTRING("Aborted.mfasl")); #else file->Remove(PR_FALSE); #endif } // If the list is empty now, the FastLoad process is done. NS_RELEASE(gFastLoadService); NS_RELEASE(gFastLoadFile); }
nsresult nsMsgSearchOfflineMail::Search(bool *aDone) { nsresult err = NS_OK; NS_ENSURE_ARG(aDone); nsresult dbErr = NS_OK; nsCOMPtr<nsIMsgDBHdr> msgDBHdr; nsMsgSearchBoolExpression *expressionTree = nullptr; const uint32_t kTimeSliceInMS = 200; *aDone = false; // Try to open the DB lazily. This will set up a parser if one is required if (!m_db) err = OpenSummaryFile (); if (!m_db) // must be reparsing. return err; // Reparsing is unnecessary or completed if (NS_SUCCEEDED(err)) { if (!m_listContext) dbErr = m_db->ReverseEnumerateMessages(getter_AddRefs(m_listContext)); if (NS_SUCCEEDED(dbErr) && m_listContext) { PRIntervalTime startTime = PR_IntervalNow(); while (!*aDone) // we'll break out of the loop after kTimeSliceInMS milliseconds { nsCOMPtr<nsISupports> currentItem; dbErr = m_listContext->GetNext(getter_AddRefs(currentItem)); if(NS_SUCCEEDED(dbErr)) { msgDBHdr = do_QueryInterface(currentItem, &dbErr); } if (NS_FAILED(dbErr)) *aDone = true; //###phil dbErr is dropped on the floor. just note that we did have an error so we'll clean up later else { bool match = false; nsAutoString nullCharset, folderCharset; GetSearchCharsets(nullCharset, folderCharset); NS_ConvertUTF16toUTF8 charset(folderCharset); // Is this message a hit? err = MatchTermsForSearch (msgDBHdr, m_searchTerms, charset.get(), m_scope, m_db, &expressionTree, &match); // Add search hits to the results list if (NS_SUCCEEDED(err) && match) { AddResultElement (msgDBHdr); } PRIntervalTime elapsedTime = PR_IntervalNow() - startTime; // check if more than kTimeSliceInMS milliseconds have elapsed in this time slice started if (PR_IntervalToMilliseconds(elapsedTime) > kTimeSliceInMS) break; } } } } else *aDone = true; // we couldn't open up the DB. This is an unrecoverable error so mark the scope as done. delete expressionTree; // in the past an error here would cause an "infinite" search because the url would continue to run... // i.e. if we couldn't open the database, it returns an error code but the caller of this function says, oh, // we did not finish so continue...what we really want is to treat this current scope as done if (*aDone) CleanUpScope(); // Do clean up for end-of-scope processing return err; }
nsresult nsXULPrototypeCache::StartFastLoad(nsIURI* aURI) { nsresult rv; nsCAutoString path; aURI->GetPath(path); if (!StringEndsWith(path, NS_LITERAL_CSTRING(".xul"))) return NS_ERROR_NOT_AVAILABLE; // Test gFastLoadFile to decide whether this is the first nsXULDocument // participating in FastLoad. If gFastLoadFile is non-null, this document // must not be first, but it can join the FastLoad process. Examples of // multiple master documents participating include hiddenWindow.xul and // navigator.xul on the Mac, and multiple-app-component (e.g., mailnews // and browser) startup due to command-line arguments. // // XXXbe we should attempt to update the FastLoad file after startup! // // XXXbe we do not yet use nsFastLoadPtrs, but once we do, we must keep // the FastLoad input stream open for the life of the app. if (gFastLoadService && gFastLoadFile) { mFastLoadURITable.Put(aURI, 1); return NS_OK; } // Use a local to refer to the service till we're sure we succeeded, then // commit to gFastLoadService. Same for gFastLoadFile, which is used to // delete the FastLoad file on abort. nsCOMPtr<nsIFastLoadService> fastLoadService(do_GetFastLoadService()); if (! fastLoadService) return NS_ERROR_FAILURE; gDisableXULFastLoad = nsContentUtils::GetBoolPref(kDisableXULFastLoadPref, gDisableXULFastLoad); gChecksumXULFastLoadFile = nsContentUtils::GetBoolPref(kChecksumXULFastLoadFilePref, gChecksumXULFastLoadFile); nsContentUtils::RegisterPrefCallback(kDisableXULFastLoadPref, FastLoadPrefChangedCallback, nsnull); nsContentUtils::RegisterPrefCallback(kChecksumXULFastLoadFilePref, FastLoadPrefChangedCallback, nsnull); if (gDisableXULFastLoad) return NS_ERROR_NOT_AVAILABLE; // Get the chrome directory to validate against the one stored in the // FastLoad file, or to store there if we're generating a new file. nsCOMPtr<nsIFile> chromeDir; rv = NS_GetSpecialDirectory(NS_APP_CHROME_DIR, getter_AddRefs(chromeDir)); if (NS_FAILED(rv)) return rv; nsCAutoString chromePath; rv = chromeDir->GetNativePath(chromePath); if (NS_FAILED(rv)) return rv; nsCOMPtr<nsIFile> file; rv = fastLoadService->NewFastLoadFile(XUL_FASTLOAD_FILE_BASENAME, getter_AddRefs(file)); if (NS_FAILED(rv)) return rv; // Give the FastLoad service an object by which it can get or create a // file output stream given an input stream on the same file. nsXULFastLoadFileIO* xio = new nsXULFastLoadFileIO(file); nsCOMPtr<nsIFastLoadFileIO> io = static_cast<nsIFastLoadFileIO*>(xio); if (! io) return NS_ERROR_OUT_OF_MEMORY; fastLoadService->SetFileIO(io); nsCOMPtr<nsIXULChromeRegistry> chromeReg(do_GetService(NS_CHROMEREGISTRY_CONTRACTID, &rv)); if (NS_FAILED(rv)) return rv; // XXXbe we assume the first package's locale is the same as the locale of // all subsequent packages of FastLoaded chrome URIs.... nsCAutoString package; rv = aURI->GetHost(package); if (NS_FAILED(rv)) return rv; nsCAutoString locale; rv = chromeReg->GetSelectedLocale(package, locale); if (NS_FAILED(rv)) return rv; // Try to read an existent FastLoad file. PRBool exists = PR_FALSE; if (NS_SUCCEEDED(file->Exists(&exists)) && exists) { nsCOMPtr<nsIObjectInputStream> objectInput; rv = fastLoadService->NewInputStream(file, getter_AddRefs(objectInput)); if (NS_SUCCEEDED(rv)) { if (NS_SUCCEEDED(rv)) { // Get the XUL fastload file version number, which should be // decremented whenever the XUL-specific file format changes // (see public/nsIXULPrototypeCache.h for the #define). PRUint32 xulFastLoadVersion, jsByteCodeVersion; rv = objectInput->Read32(&xulFastLoadVersion); rv |= objectInput->Read32(&jsByteCodeVersion); if (NS_SUCCEEDED(rv)) { if (xulFastLoadVersion != XUL_FASTLOAD_FILE_VERSION || jsByteCodeVersion != JSXDR_BYTECODE_VERSION) { #ifdef DEBUG printf((xulFastLoadVersion != XUL_FASTLOAD_FILE_VERSION) ? "bad FastLoad file version\n" : "bad JS bytecode version\n"); #endif rv = NS_ERROR_UNEXPECTED; } else { nsCAutoString fileChromePath, fileLocale; rv = objectInput->ReadCString(fileChromePath); rv |= objectInput->ReadCString(fileLocale); if (NS_SUCCEEDED(rv) && (!fileChromePath.Equals(chromePath) || !fileLocale.Equals(locale))) { rv = NS_ERROR_UNEXPECTED; } } } } } if (NS_SUCCEEDED(rv)) { fastLoadService->SetInputStream(objectInput); } else { // NB: we must close before attempting to remove, for non-Unix OSes // that can't do open-unlink. if (objectInput) objectInput->Close(); xio->mInputStream = nsnull; #ifdef DEBUG file->MoveToNative(nsnull, NS_LITERAL_CSTRING("Invalid.mfasl")); #else file->Remove(PR_FALSE); #endif exists = PR_FALSE; } } // FastLoad file not found, or invalid: write a new one. if (! exists) { nsCOMPtr<nsIOutputStream> output; rv = io->GetOutputStream(getter_AddRefs(output)); if (NS_FAILED(rv)) return rv; nsCOMPtr<nsIObjectOutputStream> objectOutput; rv = fastLoadService->NewOutputStream(output, getter_AddRefs(objectOutput)); if (NS_SUCCEEDED(rv)) { rv = objectOutput->Write32(XUL_FASTLOAD_FILE_VERSION); rv |= objectOutput->Write32(JSXDR_BYTECODE_VERSION); rv |= objectOutput->WriteStringZ(chromePath.get()); rv |= objectOutput->WriteStringZ(locale.get()); } // Remove here even though some errors above will lead to a FastLoad // file invalidation. Other errors (failure to note the dependency on // installed-chrome.txt, e.g.) will not cause invalidation, and we may // as well tidy up now. if (NS_FAILED(rv)) { if (objectOutput) objectOutput->Close(); else output->Close(); xio->mOutputStream = nsnull; file->Remove(PR_FALSE); return NS_ERROR_FAILURE; } fastLoadService->SetOutputStream(objectOutput); } // Success! Insert this URI into the mFastLoadURITable // and commit locals to globals. mFastLoadURITable.Put(aURI, 1); NS_ADDREF(gFastLoadService = fastLoadService); NS_ADDREF(gFastLoadFile = file); return NS_OK; }
nsresult EventListenerManager::SetEventHandler(nsIAtom* aName, const nsAString& aBody, bool aDeferCompilation, bool aPermitUntrustedEvents, Element* aElement) { nsCOMPtr<nsIDocument> doc; nsCOMPtr<nsIScriptGlobalObject> global = GetScriptGlobalAndDocument(getter_AddRefs(doc)); if (!global) { // This can happen; for example this document might have been // loaded as data. return NS_OK; } #ifdef DEBUG nsCOMPtr<nsPIDOMWindow> win = do_QueryInterface(global); if (win) { MOZ_ASSERT(win->IsInnerWindow(), "We should not have an outer window here!"); } #endif nsresult rv = NS_OK; // return early preventing the event listener from being added // 'doc' is fetched above if (doc) { // Don't allow adding an event listener if the document is sandboxed // without 'allow-scripts'. if (doc->GetSandboxFlags() & SANDBOXED_SCRIPTS) { return NS_ERROR_DOM_SECURITY_ERR; } nsCOMPtr<nsIContentSecurityPolicy> csp; rv = doc->NodePrincipal()->GetCsp(getter_AddRefs(csp)); NS_ENSURE_SUCCESS(rv, rv); if (csp) { bool inlineOK = true; bool reportViolations = false; rv = csp->GetAllowsInlineScript(&reportViolations, &inlineOK); NS_ENSURE_SUCCESS(rv, rv); if (reportViolations) { // gather information to log with violation report nsIURI* uri = doc->GetDocumentURI(); nsAutoCString asciiSpec; if (uri) uri->GetAsciiSpec(asciiSpec); nsAutoString scriptSample, attr, tagName(NS_LITERAL_STRING("UNKNOWN")); aName->ToString(attr); nsCOMPtr<nsIDOMNode> domNode(do_QueryInterface(mTarget)); if (domNode) domNode->GetNodeName(tagName); // build a "script sample" based on what we know about this element scriptSample.Assign(attr); scriptSample.AppendLiteral(" attribute on "); scriptSample.Append(tagName); scriptSample.AppendLiteral(" element"); csp->LogViolationDetails(nsIContentSecurityPolicy::VIOLATION_TYPE_INLINE_SCRIPT, NS_ConvertUTF8toUTF16(asciiSpec), scriptSample, 0, EmptyString(), EmptyString()); } // return early if CSP wants us to block inline scripts if (!inlineOK) { return NS_OK; } } } // This might be the first reference to this language in the global // We must init the language before we attempt to fetch its context. if (NS_FAILED(global->EnsureScriptEnvironment())) { NS_WARNING("Failed to setup script environment for this language"); // but fall through and let the inevitable failure below handle it. } nsIScriptContext* context = global->GetScriptContext(); NS_ENSURE_TRUE(context, NS_ERROR_FAILURE); NS_ENSURE_STATE(global->GetGlobalJSObject()); Listener* listener = SetEventHandlerInternal(aName, EmptyString(), TypedEventHandler(), aPermitUntrustedEvents); if (!aDeferCompilation) { return CompileEventHandlerInternal(listener, &aBody, aElement); } return NS_OK; }
static nsresult InitOperators(void) { // Load the property file containing the Operator Dictionary nsresult rv; nsCOMPtr<nsIPersistentProperties> mathfontProp; rv = NS_LoadPersistentPropertiesFromURISpec(getter_AddRefs(mathfontProp), NS_LITERAL_CSTRING("resource://gre/res/fonts/mathfont.properties")); if (NS_FAILED(rv)) return rv; // Get the list of invariant chars for (int32_t i = 0; i < eMATHVARIANT_COUNT; ++i) { nsAutoCString key(NS_LITERAL_CSTRING("mathvariant.")); key.Append(kMathVariant_name[i]); nsAutoString value; mathfontProp->GetStringProperty(key, value); gInvariantCharArray->AppendElement(value); // i.e., gInvariantCharArray[i] holds this list } // Parse the Operator Dictionary in two passes. // The first pass is to count the number of operators; the second pass is to // allocate the necessary space for them and to add them in the hash table. for (int32_t pass = 1; pass <= 2; pass++) { OperatorData dummyData; OperatorData* operatorData = &dummyData; nsCOMPtr<nsISimpleEnumerator> iterator; if (NS_SUCCEEDED(mathfontProp->Enumerate(getter_AddRefs(iterator)))) { bool more; uint32_t index = 0; nsAutoCString name; nsAutoString attributes; while ((NS_SUCCEEDED(iterator->HasMoreElements(&more))) && more) { nsCOMPtr<nsIPropertyElement> element; if (NS_SUCCEEDED(iterator->GetNext(getter_AddRefs(element)))) { if (NS_SUCCEEDED(element->GetKey(name)) && NS_SUCCEEDED(element->GetValue(attributes))) { // expected key: operator.\uNNNN.{infix,postfix,prefix} if ((21 <= name.Length()) && (0 == name.Find("operator.\\u"))) { name.Cut(0, 9); // 9 is the length of "operator."; int32_t len = name.Length(); nsOperatorFlags form = 0; if (kNotFound != name.RFind(".infix")) { form = NS_MATHML_OPERATOR_FORM_INFIX; len -= 6; // 6 is the length of ".infix"; } else if (kNotFound != name.RFind(".postfix")) { form = NS_MATHML_OPERATOR_FORM_POSTFIX; len -= 8; // 8 is the length of ".postfix"; } else if (kNotFound != name.RFind(".prefix")) { form = NS_MATHML_OPERATOR_FORM_PREFIX; len -= 7; // 7 is the length of ".prefix"; } else continue; // input is not applicable name.SetLength(len); if (2 == pass) { // allocate space and start the storage if (!gOperatorArray) { if (0 == gOperatorCount) return NS_ERROR_UNEXPECTED; gOperatorArray = new OperatorData[gOperatorCount]; if (!gOperatorArray) return NS_ERROR_OUT_OF_MEMORY; } operatorData = &gOperatorArray[index]; } else { form = 0; // to quickly return from SetOperator() at pass 1 } // See if the operator should be retained if (SetOperator(operatorData, form, name, attributes)) { index++; if (1 == pass) gOperatorCount = index; } } } } } } } return NS_OK; }
nsresult EventListenerManager::CompileEventHandlerInternal(Listener* aListener, const nsAString* aBody, Element* aElement) { MOZ_ASSERT(aListener->GetJSEventHandler()); MOZ_ASSERT(aListener->mHandlerIsString, "Why are we compiling a non-string JS listener?"); JSEventHandler* jsEventHandler = aListener->GetJSEventHandler(); MOZ_ASSERT(!jsEventHandler->GetTypedEventHandler().HasEventHandler(), "What is there to compile?"); nsresult result = NS_OK; nsCOMPtr<nsIDocument> doc; nsCOMPtr<nsIScriptGlobalObject> global = GetScriptGlobalAndDocument(getter_AddRefs(doc)); NS_ENSURE_STATE(global); // Activate JSAPI, and make sure that exceptions are reported on the right // Window. AutoJSAPI jsapi; if (NS_WARN_IF(!jsapi.Init(global))) { return NS_ERROR_UNEXPECTED; } jsapi.TakeOwnershipOfErrorReporting(); JSContext* cx = jsapi.cx(); nsCOMPtr<nsIAtom> typeAtom = aListener->mTypeAtom; nsIAtom* attrName = typeAtom; // Flag us as not a string so we don't keep trying to compile strings which // can't be compiled. aListener->mHandlerIsString = false; // mTarget may not be an Element if it's a window and we're // getting an inline event listener forwarded from <html:body> or // <html:frameset> or <xul:window> or the like. // XXX I don't like that we have to reference content from // here. The alternative is to store the event handler string on // the JSEventHandler itself, and that still doesn't address // the arg names issue. nsCOMPtr<Element> element = do_QueryInterface(mTarget); MOZ_ASSERT(element || aBody, "Where will we get our body?"); nsAutoString handlerBody; const nsAString* body = aBody; if (!aBody) { if (aListener->mTypeAtom == nsGkAtoms::onSVGLoad) { attrName = nsGkAtoms::onload; } else if (aListener->mTypeAtom == nsGkAtoms::onSVGUnload) { attrName = nsGkAtoms::onunload; } else if (aListener->mTypeAtom == nsGkAtoms::onSVGResize) { attrName = nsGkAtoms::onresize; } else if (aListener->mTypeAtom == nsGkAtoms::onSVGScroll) { attrName = nsGkAtoms::onscroll; } else if (aListener->mTypeAtom == nsGkAtoms::onSVGZoom) { attrName = nsGkAtoms::onzoom; } else if (aListener->mTypeAtom == nsGkAtoms::onbeginEvent) { attrName = nsGkAtoms::onbegin; } else if (aListener->mTypeAtom == nsGkAtoms::onrepeatEvent) { attrName = nsGkAtoms::onrepeat; } else if (aListener->mTypeAtom == nsGkAtoms::onendEvent) { attrName = nsGkAtoms::onend; } element->GetAttr(kNameSpaceID_None, attrName, handlerBody); body = &handlerBody; aElement = element; } aListener = nullptr; uint32_t lineNo = 0; nsAutoCString url (NS_LITERAL_CSTRING("-moz-evil:lying-event-listener")); MOZ_ASSERT(body); MOZ_ASSERT(aElement); nsIURI *uri = aElement->OwnerDoc()->GetDocumentURI(); if (uri) { uri->GetSpec(url); lineNo = 1; } nsCOMPtr<nsPIDOMWindow> win = do_QueryInterface(mTarget); uint32_t argCount; const char **argNames; nsContentUtils::GetEventArgNames(aElement->GetNameSpaceID(), typeAtom, win, &argCount, &argNames); JSAddonId *addonId = MapURIToAddonID(uri); // Wrap the event target, so that we can use it as the scope for the event // handler. Note that mTarget is different from aElement in the <body> case, // where mTarget is a Window. // // The wrapScope doesn't really matter here, because the target will create // its reflector in the proper scope, and then we'll enter that compartment. JS::Rooted<JSObject*> wrapScope(cx, global->GetGlobalJSObject()); JS::Rooted<JS::Value> v(cx); { JSAutoCompartment ac(cx, wrapScope); nsresult rv = nsContentUtils::WrapNative(cx, mTarget, &v, /* aAllowWrapping = */ false); if (NS_WARN_IF(NS_FAILED(rv))) { return rv; } } if (addonId) { JS::Rooted<JSObject*> vObj(cx, &v.toObject()); JS::Rooted<JSObject*> addonScope(cx, xpc::GetAddonScope(cx, vObj, addonId)); if (!addonScope) { return NS_ERROR_FAILURE; } JSAutoCompartment ac(cx, addonScope); // Wrap our event target into the addon scope, since that's where we want to // do all our work. if (!JS_WrapValue(cx, &v)) { return NS_ERROR_FAILURE; } } JS::Rooted<JSObject*> target(cx, &v.toObject()); JSAutoCompartment ac(cx, target); // Now that we've entered the compartment we actually care about, create our // scope chain. Note that we start with |element|, not aElement, because // mTarget is different from aElement in the <body> case, where mTarget is a // Window, and in that case we do not want the scope chain to include the body // or the document. JS::AutoObjectVector scopeChain(cx); if (!nsJSUtils::GetScopeChainForElement(cx, element, scopeChain)) { return NS_ERROR_OUT_OF_MEMORY; } nsDependentAtomString str(attrName); // Most of our names are short enough that we don't even have to malloc // the JS string stuff, so don't worry about playing games with // refcounting XPCOM stringbuffers. JS::Rooted<JSString*> jsStr(cx, JS_NewUCStringCopyN(cx, str.BeginReading(), str.Length())); NS_ENSURE_TRUE(jsStr, NS_ERROR_OUT_OF_MEMORY); // Get the reflector for |aElement|, so that we can pass to setElement. if (NS_WARN_IF(!GetOrCreateDOMReflector(cx, target, aElement, &v))) { return NS_ERROR_FAILURE; } JS::CompileOptions options(cx); options.setIntroductionType("eventHandler") .setFileAndLine(url.get(), lineNo) .setVersion(JSVERSION_DEFAULT) .setElement(&v.toObject()) .setElementAttributeName(jsStr); JS::Rooted<JSObject*> handler(cx); result = nsJSUtils::CompileFunction(jsapi, scopeChain, options, nsAtomCString(typeAtom), argCount, argNames, *body, handler.address()); NS_ENSURE_SUCCESS(result, result); NS_ENSURE_TRUE(handler, NS_ERROR_FAILURE); if (jsEventHandler->EventName() == nsGkAtoms::onerror && win) { nsRefPtr<OnErrorEventHandlerNonNull> handlerCallback = new OnErrorEventHandlerNonNull(handler, /* aIncumbentGlobal = */ nullptr); jsEventHandler->SetHandler(handlerCallback); } else if (jsEventHandler->EventName() == nsGkAtoms::onbeforeunload && win) { nsRefPtr<OnBeforeUnloadEventHandlerNonNull> handlerCallback = new OnBeforeUnloadEventHandlerNonNull(handler, /* aIncumbentGlobal = */ nullptr); jsEventHandler->SetHandler(handlerCallback); } else { nsRefPtr<EventHandlerNonNull> handlerCallback = new EventHandlerNonNull(handler, /* aIncumbentGlobal = */ nullptr); jsEventHandler->SetHandler(handlerCallback); } return result; }
// // Native method InstallChrome // static JSBool InstallTriggerGlobalInstallChrome(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) { nsIDOMInstallTriggerGlobal *nativeThis = getTriggerNative(cx, obj); if (!nativeThis) return JS_FALSE; uint32 chromeType = NOT_CHROME; nsAutoString sourceURL; nsAutoString name; *rval = JSVAL_FALSE; // get chromeType first, the update enabled check for skins skips whitelisting if (argc >=1) { if (!JS_ValueToECMAUint32(cx, argv[0], &chromeType)) return JS_FALSE; } // make sure XPInstall is enabled, return if not nsIScriptGlobalObject *globalObject = nsnull; nsIScriptContext *scriptContext = GetScriptContextFromJSContext(cx); if (scriptContext) globalObject = scriptContext->GetGlobalObject(); if (!globalObject) return JS_TRUE; // get window.location to construct relative URLs nsCOMPtr<nsIURI> baseURL; JSObject* global = JS_GetGlobalObject(cx); if (global) { jsval v; if (JS_GetProperty(cx,global,"location",&v)) { nsAutoString location; ConvertJSValToStr( location, cx, v ); NS_NewURI(getter_AddRefs(baseURL), location); } } if ( argc >= 3 ) { ConvertJSValToStr(sourceURL, cx, argv[1]); ConvertJSValToStr(name, cx, argv[2]); if (baseURL) { nsCAutoString resolvedURL; baseURL->Resolve(NS_ConvertUTF16toUTF8(sourceURL), resolvedURL); sourceURL = NS_ConvertUTF8toUTF16(resolvedURL); } // Make sure caller is allowed to load this url. nsresult rv = InstallTriggerCheckLoadURIFromScript(cx, sourceURL); if (NS_FAILED(rv)) return JS_FALSE; if ( chromeType & CHROME_ALL ) { // there's at least one known chrome type nsCOMPtr<nsIURI> checkuri; nsresult rv = nativeThis->GetOriginatingURI(globalObject, getter_AddRefs(checkuri)); if (NS_SUCCEEDED(rv)) { nsAutoPtr<nsXPITriggerInfo> trigger(new nsXPITriggerInfo()); nsAutoPtr<nsXPITriggerItem> item(new nsXPITriggerItem(name.get(), sourceURL.get(), nsnull)); if (trigger && item) { // trigger will free item when complete trigger->Add(item.forget()); nsCOMPtr<nsIDOMWindowInternal> win(do_QueryInterface(globalObject)); nsCOMPtr<nsIXPIInstallInfo> installInfo = new nsXPIInstallInfo(win, checkuri, trigger, chromeType); if (installInfo) { // installInfo owns trigger now trigger.forget(); PRBool enabled = PR_FALSE; nativeThis->UpdateEnabled(checkuri, XPI_WHITELIST, &enabled); if (!enabled) { nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService(); if (os) os->NotifyObservers(installInfo, "xpinstall-install-blocked", nsnull); } else { PRBool nativeRet = PR_FALSE; nativeThis->StartInstall(installInfo, &nativeRet); *rval = BOOLEAN_TO_JSVAL(nativeRet); } } } } } } return JS_TRUE; }
NS_IMETHODIMP nsHttpNTLMAuth::GenerateCredentials(nsIHttpAuthenticableChannel *authChannel, const char *challenge, bool isProxyAuth, const char16_t *domain, const char16_t *user, const char16_t *pass, nsISupports **sessionState, nsISupports **continuationState, uint32_t *aFlags, char **creds) { LOG(("nsHttpNTLMAuth::GenerateCredentials\n")); *creds = nullptr; *aFlags = 0; // if user or password is empty, ChallengeReceived returned // identityInvalid = false, that means we are using default user // credentials; see nsAuthSSPI::Init method for explanation of this // condition if (!user || !pass) *aFlags = USING_INTERNAL_IDENTITY; nsresult rv; nsCOMPtr<nsIAuthModule> module = do_QueryInterface(*continuationState, &rv); NS_ENSURE_SUCCESS(rv, rv); void *inBuf, *outBuf; uint32_t inBufLen, outBufLen; // initial challenge if (PL_strcasecmp(challenge, "NTLM") == 0) { // NTLM service name format is 'HTTP@host' for both http and https nsCOMPtr<nsIURI> uri; rv = authChannel->GetURI(getter_AddRefs(uri)); if (NS_FAILED(rv)) return rv; nsAutoCString serviceName, host; rv = uri->GetAsciiHost(host); if (NS_FAILED(rv)) return rv; serviceName.AppendLiteral("HTTP@"); serviceName.Append(host); // initialize auth module uint32_t reqFlags = nsIAuthModule::REQ_DEFAULT; if (isProxyAuth) reqFlags |= nsIAuthModule::REQ_PROXY_AUTH; rv = module->Init(serviceName.get(), reqFlags, domain, user, pass); if (NS_FAILED(rv)) return rv; // This update enables updated Windows machines (Win7 or patched previous // versions) and Linux machines running Samba (updated for Channel // Binding), to perform Channel Binding when authenticating using NTLMv2 // and an outer secure channel. // // Currently only implemented for Windows, linux support will be landing in // a separate patch, update this #ifdef accordingly then. #if defined (XP_WIN) /* || defined (LINUX) */ // We should retrieve the server certificate and compute the CBT, // but only when we are using the native NTLM implementation and // not the internal one. // It is a valid case not having the security info object. This // occures when we connect an https site through an ntlm proxy. // After the ssl tunnel has been created, we get here the second // time and now generate the CBT from now valid security info. nsCOMPtr<nsIChannel> channel = do_QueryInterface(authChannel, &rv); if (NS_FAILED(rv)) return rv; nsCOMPtr<nsISupports> security; rv = channel->GetSecurityInfo(getter_AddRefs(security)); if (NS_FAILED(rv)) return rv; nsCOMPtr<nsISSLStatusProvider> statusProvider = do_QueryInterface(security); if (mUseNative && statusProvider) { nsCOMPtr<nsISSLStatus> status; rv = statusProvider->GetSSLStatus(getter_AddRefs(status)); if (NS_FAILED(rv)) return rv; nsCOMPtr<nsIX509Cert> cert; rv = status->GetServerCert(getter_AddRefs(cert)); if (NS_FAILED(rv)) return rv; uint32_t length; uint8_t* certArray; cert->GetRawDER(&length, &certArray); // If there is a server certificate, we pass it along the // first time we call GetNextToken(). inBufLen = length; inBuf = certArray; } else { // If there is no server certificate, we don't pass anything. inBufLen = 0; inBuf = nullptr; } #else // Extended protection update is just for Linux and Windows machines. inBufLen = 0; inBuf = nullptr; #endif } else { // decode challenge; skip past "NTLM " to the start of the base64 // encoded data. int len = strlen(challenge); if (len < 6) return NS_ERROR_UNEXPECTED; // bogus challenge challenge += 5; len -= 5; // strip off any padding (see bug 230351) while (challenge[len - 1] == '=') len--; // decode into the input secbuffer inBufLen = (len * 3)/4; // sufficient size (see plbase64.h) inBuf = nsMemory::Alloc(inBufLen); if (!inBuf) return NS_ERROR_OUT_OF_MEMORY; if (PL_Base64Decode(challenge, len, (char *) inBuf) == nullptr) { nsMemory::Free(inBuf); return NS_ERROR_UNEXPECTED; // improper base64 encoding } } rv = module->GetNextToken(inBuf, inBufLen, &outBuf, &outBufLen); if (NS_SUCCEEDED(rv)) { // base64 encode data in output buffer and prepend "NTLM " int credsLen = 5 + ((outBufLen + 2)/3)*4; *creds = (char *) nsMemory::Alloc(credsLen + 1); if (!*creds) rv = NS_ERROR_OUT_OF_MEMORY; else { memcpy(*creds, "NTLM ", 5); PL_Base64Encode((char *) outBuf, outBufLen, *creds + 5); (*creds)[credsLen] = '\0'; // null terminate } // OK, we are done with |outBuf| nsMemory::Free(outBuf); } if (inBuf) nsMemory::Free(inBuf); return rv; }
nsresult RtspMediaResource::OnConnected(uint8_t aTrackIdx, nsIStreamingProtocolMetaData *meta) { if (mIsConnected) { for (uint32_t i = 0 ; i < mTrackBuffer.Length(); ++i) { mTrackBuffer[i]->Start(); } return NS_OK; } uint8_t tracks; mMediaStreamController->GetTotalTracks(&tracks); uint64_t duration = 0; for (int i = 0; i < tracks; ++i) { nsCString rtspTrackId("RtspTrack"); rtspTrackId.AppendInt(i); nsCOMPtr<nsIStreamingProtocolMetaData> trackMeta; mMediaStreamController->GetTrackMetaData(i, getter_AddRefs(trackMeta)); MOZ_ASSERT(trackMeta); trackMeta->GetDuration(&duration); // Here is a heuristic to estimate the slot size. // For video track, calculate the width*height. // For audio track, use the BUFFER_SLOT_DEFAULT_SIZE because the w*h is 0. // Finally clamp them into (BUFFER_SLOT_DEFAULT_SIZE,BUFFER_SLOT_MAX_SIZE) uint32_t w, h; uint32_t slotSize; trackMeta->GetWidth(&w); trackMeta->GetHeight(&h); slotSize = clamped((int32_t)(w * h), BUFFER_SLOT_DEFAULT_SIZE, BUFFER_SLOT_MAX_SIZE); mTrackBuffer.AppendElement(new RtspTrackBuffer(rtspTrackId.get(), i, slotSize)); mTrackBuffer[i]->Start(); } // If the duration is 0, imply the stream is live stream. if (duration) { // Not live stream. mRealTime = false; bool seekable = true; mDecoder->SetInfinite(false); mDecoder->SetTransportSeekable(seekable); mDecoder->SetDuration(duration); } else { // Live stream. // Check the preference "media.realtime_decoder.enabled". if (!Preferences::GetBool("media.realtime_decoder.enabled", false)) { // Give up, report error to media element. nsCOMPtr<nsIRunnable> event = NS_NewRunnableMethod(mDecoder, &MediaDecoder::DecodeError); NS_DispatchToMainThread(event, NS_DISPATCH_NORMAL); return NS_ERROR_FAILURE; } else { mRealTime = true; bool seekable = false; mDecoder->SetInfinite(true); mDecoder->SetTransportSeekable(seekable); mDecoder->SetMediaSeekable(seekable); } } // Fires an initial progress event and sets up the stall counter so stall events // fire if no download occurs within the required time frame. mDecoder->Progress(false); MediaDecoderOwner* owner = mDecoder->GetMediaOwner(); NS_ENSURE_TRUE(owner, NS_ERROR_FAILURE); dom::HTMLMediaElement* element = owner->GetMediaElement(); NS_ENSURE_TRUE(element, NS_ERROR_FAILURE); element->FinishDecoderSetup(mDecoder, this); mIsConnected = true; return NS_OK; }
nsresult SaveProfileTask::Run() { // Get file path #if defined(SPS_PLAT_arm_android) && !defined(MOZ_WIDGET_GONK) nsCString tmpPath; tmpPath.AppendPrintf("/sdcard/profile_%i_%i.txt", XRE_GetProcessType(), getpid()); #else nsCOMPtr<nsIFile> tmpFile; nsAutoCString tmpPath; if (NS_FAILED(NS_GetSpecialDirectory(NS_OS_TEMP_DIR, getter_AddRefs(tmpFile)))) { LOG("Failed to find temporary directory."); return NS_ERROR_FAILURE; } tmpPath.AppendPrintf("profile_%i_%i.txt", XRE_GetProcessType(), getpid()); nsresult rv = tmpFile->AppendNative(tmpPath); if (NS_FAILED(rv)) return rv; rv = tmpFile->GetNativePath(tmpPath); if (NS_FAILED(rv)) return rv; #endif // Create a JSContext to run a JSObjectBuilder :( // Based on XPCShellEnvironment JSRuntime *rt; JSContext *cx; nsCOMPtr<nsIJSRuntimeService> rtsvc = do_GetService("@mozilla.org/js/xpc/RuntimeService;1"); if (!rtsvc || NS_FAILED(rtsvc->GetRuntime(&rt)) || !rt) { LOG("failed to get RuntimeService"); return NS_ERROR_FAILURE;; } cx = JS_NewContext(rt, 8192); if (!cx) { LOG("Failed to get context"); return NS_ERROR_FAILURE; } { JSAutoRequest ar(cx); static JSClass c = { "global", JSCLASS_GLOBAL_FLAGS, JS_PropertyStub, JS_DeletePropertyStub, JS_PropertyStub, JS_StrictPropertyStub, JS_EnumerateStub, JS_ResolveStub, JS_ConvertStub }; JSObject *obj = JS_NewGlobalObject(cx, &c, NULL, JS::FireOnNewGlobalHook); std::ofstream stream; stream.open(tmpPath.get()); if (stream.is_open()) { JSAutoCompartment autoComp(cx, obj); JSObject* profileObj = profiler_get_profile_jsobject(cx); JS::Rooted<JS::Value> val(cx, OBJECT_TO_JSVAL(profileObj)); JS_Stringify(cx, val.address(), nullptr, JSVAL_NULL, WriteCallback, &stream); stream.close(); LOGF("Saved to %s", tmpPath.get()); } else { LOG("Fail to open profile log file."); } } JS_DestroyContext(cx); return NS_OK; }
void HttpChannelChild::OnTransportAndData(const nsresult& status, const PRUint64 progress, const PRUint64& progressMax, const nsCString& data, const PRUint32& offset, const PRUint32& count) { LOG(("HttpChannelChild::OnTransportAndData [this=%x]\n", this)); if (mCanceled) return; // cache the progress sink so we don't have to query for it each time. if (!mProgressSink) GetCallback(mProgressSink); // Hold queue lock throughout all three calls, else we might process a later // necko msg in between them. AutoEventEnqueuer ensureSerialDispatch(mEventQ); // block status/progress after Cancel or OnStopRequest has been called, // or if channel has LOAD_BACKGROUND set. // - JDUELL: may not need mStatus/mIsPending checks, given this is always called // during OnDataAvailable, and we've already checked mCanceled. Code // dupe'd from nsHttpChannel if (mProgressSink && NS_SUCCEEDED(mStatus) && mIsPending && !(mLoadFlags & LOAD_BACKGROUND)) { // OnStatus // NS_ASSERTION(status == nsISocketTransport::STATUS_RECEIVING_FROM || status == nsITransport::STATUS_READING, "unexpected status code"); nsCAutoString host; mURI->GetHost(host); mProgressSink->OnStatus(this, nullptr, status, NS_ConvertUTF8toUTF16(host).get()); // OnProgress // if (progress > 0) { NS_ASSERTION(progress <= progressMax, "unexpected progress values"); mProgressSink->OnProgress(this, nullptr, progress, progressMax); } } // OnDataAvailable // // NOTE: the OnDataAvailable contract requires the client to read all the data // in the inputstream. This code relies on that ('data' will go away after // this function). Apparently the previous, non-e10s behavior was to actually // support only reading part of the data, allowing later calls to read the // rest. nsCOMPtr<nsIInputStream> stringStream; nsresult rv = NS_NewByteInputStream(getter_AddRefs(stringStream), data.get(), count, NS_ASSIGNMENT_DEPEND); if (NS_FAILED(rv)) { Cancel(rv); return; } rv = mListener->OnDataAvailable(this, mListenerContext, stringStream, offset, count); stringStream->Close(); if (NS_FAILED(rv)) { Cancel(rv); } }
nsresult sbLocalDatabaseLibraryFactory::CreateLibraryFromDatabase(nsIFile* aDatabase, sbILibrary** _retval, nsIPropertyBag2* aCreationParameters, nsString aResourceGUID /* = EmptyString() */) { NS_ENSURE_ARG_POINTER(aDatabase); NS_ENSURE_ARG_POINTER(_retval); nsresult rv; // Get a unique value for this database file. nsCOMPtr<nsIHashable> hashable = do_QueryInterface(aDatabase, &rv); NS_ENSURE_SUCCESS(rv, rv); // We have to copy the file name escaping logic from when we actually create // the database, otherwise we end up re-initizliaing the database over and over. nsCOMPtr<nsIIOService> ioService = do_GetIOService(&rv); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIURI> databaseURI; rv = NS_NewFileURI(getter_AddRefs(databaseURI), aDatabase, ioService); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIURL> databaseURL = do_QueryInterface(databaseURI, &rv); NS_ENSURE_SUCCESS(rv, rv); nsCAutoString utf8GUID; rv = databaseURL->GetFileBaseName(utf8GUID); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIFile> databaseParent; rv = aDatabase->GetParent(getter_AddRefs(databaseParent)); NS_ENSURE_SUCCESS(rv, rv); nsCAutoString fileName; rv = databaseURL->GetFileName(fileName); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIFile> escapedFile; rv = databaseParent->Clone(getter_AddRefs(escapedFile)); NS_ENSURE_SUCCESS(rv, rv); rv = escapedFile->Append(NS_ConvertUTF8toUTF16(fileName)); NS_ENSURE_SUCCESS(rv, rv); // On Windows, if the file does not exist, its hashcode is different from when it does. // If we ever attempt to get the hash code while it doesn't exist, the // nsLocalFile caches the hash code and stays incorrect. bool exists; rv = escapedFile->Exists(&exists); NS_ENSURE_SUCCESS(rv, rv); // See if we've already created this library. If we have (and it is still // alive) just return it. nsCOMPtr<nsIWeakReference> weakRef; if (exists && mCreatedLibraries.Get(hashable, getter_AddRefs(weakRef))) { nsCOMPtr<sbILibrary> existingLibrary = do_QueryReferent(weakRef, &rv); NS_ENSURE_SUCCESS(rv, rv); if (existingLibrary) { existingLibrary.swap(*_retval); return NS_OK; } mCreatedLibraries.Remove(hashable); } // If the database file does not exist, create and initalize it. Otherwise, // update it. if (!exists) { rv = InitalizeLibrary(aDatabase, aResourceGUID); NS_ENSURE_SUCCESS(rv, rv); } else { rv = UpdateLibrary(aDatabase); NS_ENSURE_SUCCESS(rv, rv); } nsCOMPtr<nsIURI> databaseLocation; rv = NS_NewFileURI(getter_AddRefs(databaseLocation), databaseParent, ioService); NS_ENSURE_SUCCESS(rv, rv); nsRefPtr<sbLocalDatabaseLibrary> library(new sbLocalDatabaseLibrary()); NS_ENSURE_TRUE(library, NS_ERROR_OUT_OF_MEMORY); nsCOMPtr<nsIPropertyBag2> creationParams = aCreationParameters; if (!creationParams) { nsCOMPtr<nsIWritablePropertyBag2> bag = do_CreateInstance(SB_PROPERTYBAG_CONTRACTID, &rv); NS_ENSURE_SUCCESS(rv, rv); rv = bag->SetPropertyAsInterface(NS_LITERAL_STRING(PROPERTY_KEY_DATABASEFILE), aDatabase); NS_ENSURE_SUCCESS(rv, rv); creationParams = do_QueryInterface(bag, &rv); NS_ENSURE_SUCCESS(rv, rv); } rv = library->Init(NS_ConvertUTF8toUTF16(utf8GUID), creationParams, this, databaseLocation); NS_ENSURE_SUCCESS(rv, rv); // Add this library to our table of created libraries. weakRef = do_GetWeakReference(NS_ISUPPORTS_CAST(sbILibrary*, library), &rv); NS_ENSURE_SUCCESS(rv, rv); bool success = mCreatedLibraries.Put(hashable, weakRef); NS_ENSURE_TRUE(success, NS_ERROR_FAILURE); NS_ADDREF(*_retval = library); return NS_OK; }
NS_IMETHODIMP IDBDatabase::Transaction(const jsval& aStoreNames, PRUint16 aMode, JSContext* aCx, PRUint8 aOptionalArgCount, nsIIDBTransaction** _retval) { NS_ASSERTION(NS_IsMainThread(), "Wrong thread!"); if (IndexedDatabaseManager::IsShuttingDown()) { return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR; } if (mClosed) { return NS_ERROR_DOM_INDEXEDDB_NOT_ALLOWED_ERR; } if (mRunningVersionChange) { return NS_ERROR_DOM_INDEXEDDB_NOT_ALLOWED_ERR; } if (aOptionalArgCount) { if (aMode != nsIIDBTransaction::READ_WRITE && aMode != nsIIDBTransaction::READ_ONLY) { return NS_ERROR_DOM_INDEXEDDB_NON_TRANSIENT_ERR; } } else { aMode = nsIIDBTransaction::READ_ONLY; } nsresult rv; nsTArray<nsString> storesToOpen; if (!JSVAL_IS_PRIMITIVE(aStoreNames)) { JSObject* obj = JSVAL_TO_OBJECT(aStoreNames); // See if this is a JS array. if (JS_IsArrayObject(aCx, obj)) { jsuint length; if (!JS_GetArrayLength(aCx, obj, &length)) { return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR; } if (!length) { return NS_ERROR_DOM_INVALID_ACCESS_ERR; } storesToOpen.SetCapacity(length); for (jsuint index = 0; index < length; index++) { jsval val; JSString* jsstr; nsDependentJSString str; if (!JS_GetElement(aCx, obj, index, &val) || !(jsstr = JS_ValueToString(aCx, val)) || !str.init(aCx, jsstr)) { return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR; } storesToOpen.AppendElement(str); } NS_ASSERTION(!storesToOpen.IsEmpty(), "Must have something here or else code below will " "misbehave!"); } else { // Perhaps some kind of wrapped object? nsIXPConnect* xpc = nsContentUtils::XPConnect(); NS_ASSERTION(xpc, "This should never be null!"); nsCOMPtr<nsIXPConnectWrappedNative> wrapper; rv = xpc->GetWrappedNativeOfJSObject(aCx, obj, getter_AddRefs(wrapper)); NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR); if (wrapper) { nsISupports* wrappedObject = wrapper->Native(); NS_ENSURE_TRUE(wrappedObject, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR); // We only accept DOMStringList. nsCOMPtr<nsIDOMDOMStringList> list = do_QueryInterface(wrappedObject); if (list) { PRUint32 length; rv = list->GetLength(&length); NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR); if (!length) { return NS_ERROR_DOM_INVALID_ACCESS_ERR; } storesToOpen.SetCapacity(length); for (PRUint32 index = 0; index < length; index++) { nsString* item = storesToOpen.AppendElement(); NS_ASSERTION(item, "This should never fail!"); rv = list->Item(index, *item); NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR); } NS_ASSERTION(!storesToOpen.IsEmpty(), "Must have something here or else code below will " "misbehave!"); } } } } // If our list is empty here then the argument must have been an object that // we don't support or a primitive. Either way we convert to a string. if (storesToOpen.IsEmpty()) { JSString* jsstr; nsDependentJSString str; if (!(jsstr = JS_ValueToString(aCx, aStoreNames)) || !str.init(aCx, jsstr)) { return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR; } storesToOpen.AppendElement(str); } // Now check to make sure the object store names we collected actually exist. DatabaseInfo* info = Info(); for (PRUint32 index = 0; index < storesToOpen.Length(); index++) { if (!info->ContainsStoreName(storesToOpen[index])) { return NS_ERROR_DOM_INDEXEDDB_NOT_FOUND_ERR; } } nsRefPtr<IDBTransaction> transaction = IDBTransaction::Create(this, storesToOpen, aMode, false); NS_ENSURE_TRUE(transaction, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR); transaction.forget(_retval); return NS_OK; }
/* virtual */ nsresult nsMathMLmmultiscriptsFrame::Place(nsRenderingContext& aRenderingContext, bool aPlaceOrigin, nsHTMLReflowMetrics& aDesiredSize) { //////////////////////////////////// // Get the children's desired sizes nscoord minShiftFromXHeight, subDrop, supDrop; //////////////////////////////////////// // Initialize super/sub shifts that // depend only on the current font //////////////////////////////////////// ProcessAttributes(); // get x-height (an ex) const nsStyleFont* font = GetStyleFont(); nsRefPtr<nsFontMetrics> fm; nsLayoutUtils::GetFontMetricsForFrame(this, getter_AddRefs(fm)); aRenderingContext.SetFont(fm); nscoord xHeight = fm->XHeight(); nscoord ruleSize; GetRuleThickness (aRenderingContext, fm, ruleSize); // scriptspace from TeX for extra spacing after sup/subscript (0.5pt in plain TeX) // forced to be at least 1 pixel here nscoord onePixel = nsPresContext::CSSPixelsToAppUnits(1); nscoord scriptSpace = NS_MAX(nsPresContext::CSSPointsToAppUnits(0.5f), onePixel); ///////////////////////////////////// // first the shift for the subscript // subScriptShift{1,2} // = minimum amount to shift the subscript down // = sub{1,2} in TeXbook // subScriptShift1 = subscriptshift attribute * x-height nscoord subScriptShift1, subScriptShift2; // Get subScriptShift{1,2} default from font GetSubScriptShifts (fm, subScriptShift1, subScriptShift2); if (0 < mSubScriptShift) { // the user has set the subscriptshift attribute float scaler = ((float) subScriptShift2) / subScriptShift1; subScriptShift1 = NS_MAX(subScriptShift1, mSubScriptShift); subScriptShift2 = NSToCoordRound(scaler * subScriptShift1); } // the font dependent shift nscoord subScriptShift = NS_MAX(subScriptShift1,subScriptShift2); ///////////////////////////////////// // next the shift for the superscript // supScriptShift{1,2,3} // = minimum amount to shift the supscript up // = sup{1,2,3} in TeX // supScriptShift1 = superscriptshift attribute * x-height // Note that there are THREE values for supscript shifts depending // on the current style nscoord supScriptShift1, supScriptShift2, supScriptShift3; // Set supScriptShift{1,2,3} default from font GetSupScriptShifts (fm, supScriptShift1, supScriptShift2, supScriptShift3); if (0 < mSupScriptShift) { // the user has set the superscriptshift attribute float scaler2 = ((float) supScriptShift2) / supScriptShift1; float scaler3 = ((float) supScriptShift3) / supScriptShift1; supScriptShift1 = NS_MAX(supScriptShift1, mSupScriptShift); supScriptShift2 = NSToCoordRound(scaler2 * supScriptShift1); supScriptShift3 = NSToCoordRound(scaler3 * supScriptShift1); } // get sup script shift depending on current script level and display style // Rule 18c, App. G, TeXbook nscoord supScriptShift; if ( font->mScriptLevel == 0 && NS_MATHML_IS_DISPLAYSTYLE(mPresentationData.flags) && !NS_MATHML_IS_COMPRESSED(mPresentationData.flags)) { // Style D in TeXbook supScriptShift = supScriptShift1; } else if (NS_MATHML_IS_COMPRESSED(mPresentationData.flags)) { // Style C' in TeXbook = D',T',S',SS' supScriptShift = supScriptShift3; } else { // everything else = T,S,SS supScriptShift = supScriptShift2; } //////////////////////////////////// // Get the children's sizes //////////////////////////////////// nscoord width = 0, prescriptsWidth = 0, rightBearing = 0; nsIFrame* mprescriptsFrame = nsnull; // frame of <mprescripts/>, if there. bool isSubScript = false; nscoord minSubScriptShift = 0, minSupScriptShift = 0; nscoord trySubScriptShift = subScriptShift; nscoord trySupScriptShift = supScriptShift; nscoord maxSubScriptShift = subScriptShift; nscoord maxSupScriptShift = supScriptShift; PRInt32 count = 0; nsHTMLReflowMetrics baseSize; nsHTMLReflowMetrics subScriptSize; nsHTMLReflowMetrics supScriptSize; nsIFrame* baseFrame = nsnull; nsIFrame* subScriptFrame = nsnull; nsIFrame* supScriptFrame = nsnull; bool firstPrescriptsPair = false; nsBoundingMetrics bmBase, bmSubScript, bmSupScript; nscoord italicCorrection = 0; mBoundingMetrics.width = 0; mBoundingMetrics.ascent = mBoundingMetrics.descent = -0x7FFFFFFF; nscoord ascent = -0x7FFFFFFF, descent = -0x7FFFFFFF; aDesiredSize.width = aDesiredSize.height = 0; nsIFrame* childFrame = mFrames.FirstChild(); while (childFrame) { if (childFrame->GetContent()->Tag() == nsGkAtoms::mprescripts_) { if (mprescriptsFrame) { // duplicate <mprescripts/> found // report an error, encourage people to get their markups in order return ReflowError(aRenderingContext, aDesiredSize); } mprescriptsFrame = childFrame; firstPrescriptsPair = true; } else { if (0 == count) { // base baseFrame = childFrame; GetReflowAndBoundingMetricsFor(baseFrame, baseSize, bmBase); GetItalicCorrection(bmBase, italicCorrection); // for the superscript, we always add "a little to spare" italicCorrection += onePixel; // we update mBoundingMetrics.{ascent,descent} with that // of the baseFrame only after processing all the sup/sub pairs // XXX need italic correction only *if* there are postscripts ? mBoundingMetrics.width = bmBase.width + italicCorrection; mBoundingMetrics.rightBearing = bmBase.rightBearing; mBoundingMetrics.leftBearing = bmBase.leftBearing; // until overwritten } else { // super/subscript block if (isSubScript) { // subscript subScriptFrame = childFrame; GetReflowAndBoundingMetricsFor(subScriptFrame, subScriptSize, bmSubScript); // get the subdrop from the subscript font GetSubDropFromChild (subScriptFrame, subDrop); // parameter v, Rule 18a, App. G, TeXbook minSubScriptShift = bmBase.descent + subDrop; trySubScriptShift = NS_MAX(minSubScriptShift,subScriptShift); mBoundingMetrics.descent = NS_MAX(mBoundingMetrics.descent,bmSubScript.descent); descent = NS_MAX(descent,subScriptSize.height - subScriptSize.ascent); width = bmSubScript.width + scriptSpace; rightBearing = bmSubScript.rightBearing; } else { // supscript supScriptFrame = childFrame; GetReflowAndBoundingMetricsFor(supScriptFrame, supScriptSize, bmSupScript); // get the supdrop from the supscript font GetSupDropFromChild (supScriptFrame, supDrop); // parameter u, Rule 18a, App. G, TeXbook minSupScriptShift = bmBase.ascent - supDrop; // get min supscript shift limit from x-height // = d(x) + 1/4 * sigma_5, Rule 18c, App. G, TeXbook minShiftFromXHeight = NSToCoordRound ((bmSupScript.descent + (1.0f/4.0f) * xHeight)); trySupScriptShift = NS_MAX(minSupScriptShift,NS_MAX(minShiftFromXHeight,supScriptShift)); mBoundingMetrics.ascent = NS_MAX(mBoundingMetrics.ascent,bmSupScript.ascent); ascent = NS_MAX(ascent,supScriptSize.ascent); width = NS_MAX(width, bmSupScript.width + scriptSpace); rightBearing = NS_MAX(rightBearing, bmSupScript.rightBearing); if (!mprescriptsFrame) { // we are still looping over base & postscripts mBoundingMetrics.rightBearing = mBoundingMetrics.width + rightBearing; mBoundingMetrics.width += width; } else { prescriptsWidth += width; if (firstPrescriptsPair) { firstPrescriptsPair = false; mBoundingMetrics.leftBearing = NS_MIN(bmSubScript.leftBearing, bmSupScript.leftBearing); } } width = rightBearing = 0; // negotiate between the various shifts so that // there is enough gap between the sup and subscripts // Rule 18e, App. G, TeXbook nscoord gap = (trySupScriptShift - bmSupScript.descent) - (bmSubScript.ascent - trySubScriptShift); if (gap < 4.0f * ruleSize) { // adjust trySubScriptShift to get a gap of (4.0 * ruleSize) trySubScriptShift += NSToCoordRound ((4.0f * ruleSize) - gap); } // next we want to ensure that the bottom of the superscript // will be > (4/5) * x-height above baseline gap = NSToCoordRound ((4.0f/5.0f) * xHeight - (trySupScriptShift - bmSupScript.descent)); if (gap > 0.0f) { trySupScriptShift += gap; trySubScriptShift -= gap; } maxSubScriptShift = NS_MAX(maxSubScriptShift, trySubScriptShift); maxSupScriptShift = NS_MAX(maxSupScriptShift, trySupScriptShift); trySubScriptShift = subScriptShift; trySupScriptShift = supScriptShift; } } isSubScript = !isSubScript; } count++; childFrame = childFrame->GetNextSibling(); } // note: width=0 if all sup-sub pairs match correctly if ((0 != width) || !baseFrame || !subScriptFrame || !supScriptFrame) { // report an error, encourage people to get their markups in order return ReflowError(aRenderingContext, aDesiredSize); } // we left out the width of prescripts, so ... mBoundingMetrics.rightBearing += prescriptsWidth; mBoundingMetrics.width += prescriptsWidth; // we left out the base during our bounding box updates, so ... mBoundingMetrics.ascent = NS_MAX(mBoundingMetrics.ascent+maxSupScriptShift,bmBase.ascent); mBoundingMetrics.descent = NS_MAX(mBoundingMetrics.descent+maxSubScriptShift,bmBase.descent); // get the reflow metrics ... aDesiredSize.ascent = NS_MAX(ascent+maxSupScriptShift,baseSize.ascent); aDesiredSize.height = aDesiredSize.ascent + NS_MAX(descent+maxSubScriptShift,baseSize.height - baseSize.ascent); aDesiredSize.width = mBoundingMetrics.width; aDesiredSize.mBoundingMetrics = mBoundingMetrics; mReference.x = 0; mReference.y = aDesiredSize.ascent; ////////////////// // Place Children // Place prescripts, followed by base, and then postscripts. // The list of frames is in the order: {base} {postscripts} {prescripts} // We go over the list in a circular manner, starting at <prescripts/> if (aPlaceOrigin) { nscoord dx = 0, dy = 0; count = 0; childFrame = mprescriptsFrame; do { if (!childFrame) { // end of prescripts, // place the base ... childFrame = baseFrame; dy = aDesiredSize.ascent - baseSize.ascent; FinishReflowChild (baseFrame, PresContext(), nsnull, baseSize, MirrorIfRTL(aDesiredSize.width, baseSize.width, dx), dy, 0); dx += bmBase.width + italicCorrection; } else if (mprescriptsFrame != childFrame) { // process each sup/sub pair if (0 == count) { subScriptFrame = childFrame; count = 1; } else if (1 == count) { supScriptFrame = childFrame; count = 0; // get the ascent/descent of sup/subscripts stored in their rects // rect.x = descent, rect.y = ascent GetReflowAndBoundingMetricsFor(subScriptFrame, subScriptSize, bmSubScript); GetReflowAndBoundingMetricsFor(supScriptFrame, supScriptSize, bmSupScript); // center w.r.t. largest width width = NS_MAX(subScriptSize.width, supScriptSize.width); dy = aDesiredSize.ascent - subScriptSize.ascent + maxSubScriptShift; FinishReflowChild (subScriptFrame, PresContext(), nsnull, subScriptSize, MirrorIfRTL(aDesiredSize.width, subScriptSize.width, dx + (width-subScriptSize.width)/2), dy, 0); dy = aDesiredSize.ascent - supScriptSize.ascent - maxSupScriptShift; FinishReflowChild (supScriptFrame, PresContext(), nsnull, supScriptSize, MirrorIfRTL(aDesiredSize.width, supScriptSize.width, dx + (width-supScriptSize.width)/2), dy, 0); dx += width + scriptSpace; } } childFrame = childFrame->GetNextSibling(); } while (mprescriptsFrame != childFrame); } return NS_OK; }