NS_IMETHODIMP nsAppStartup::CreateChromeWindow2(nsIWebBrowserChrome *aParent, PRUint32 aChromeFlags, PRUint32 aContextFlags, nsIURI *aURI, PRBool *aCancel, nsIWebBrowserChrome **_retval) { NS_ENSURE_ARG_POINTER(aCancel); NS_ENSURE_ARG_POINTER(_retval); *aCancel = PR_FALSE; *_retval = 0; // Non-modal windows cannot be opened if we are attempting to quit if (mAttemptingQuit && (aChromeFlags & nsIWebBrowserChrome::CHROME_MODAL) == 0) return NS_ERROR_ILLEGAL_DURING_SHUTDOWN; nsCOMPtr<nsIXULWindow> newWindow; if (aParent) { nsCOMPtr<nsIXULWindow> xulParent(do_GetInterface(aParent)); NS_ASSERTION(xulParent, "window created using non-XUL parent. that's unexpected, but may work."); if (xulParent) xulParent->CreateNewWindow(aChromeFlags, mAppShell, getter_AddRefs(newWindow)); // And if it fails, don't try again without a parent. It could fail // intentionally (bug 115969). } else { // try using basic methods: /* You really shouldn't be making dependent windows without a parent. But unparented modal (and therefore dependent) windows happen in our codebase, so we allow it after some bellyaching: */ if (aChromeFlags & nsIWebBrowserChrome::CHROME_DEPENDENT) NS_WARNING("dependent window created without a parent"); nsCOMPtr<nsIAppShellService> appShell(do_GetService(NS_APPSHELLSERVICE_CONTRACTID)); if (!appShell) return NS_ERROR_FAILURE; appShell->CreateTopLevelWindow(0, 0, aChromeFlags, nsIAppShellService::SIZE_TO_CONTENT, nsIAppShellService::SIZE_TO_CONTENT, mAppShell, getter_AddRefs(newWindow)); } // if anybody gave us anything to work with, use it if (newWindow) { newWindow->SetContextFlags(aContextFlags); nsCOMPtr<nsIInterfaceRequestor> thing(do_QueryInterface(newWindow)); if (thing) CallGetInterface(thing.get(), _retval); } return *_retval ? NS_OK : NS_ERROR_FAILURE; }
NS_IMETHODIMP MiroWindowCreator::CreateChromeWindow2( nsIWebBrowserChrome *parent, PRUint32 chromeFlags, PRUint32 contextFlags, nsIURI *uri, PRBool *cancel, nsIWebBrowserChrome **_retval) { nsCAutoString specString; if((chromeFlags & nsIWebBrowserChrome::CHROME_OPENAS_CHROME) == 0) { *cancel = PR_TRUE; *_retval = nsnull; if(uri) { uri->GetSpec(specString); if(mWindowCallback) { mWindowCallback((char*)specString.get(), mWindowCallbackData); } } else { log_warning("Trying to open window with no URI"); } } else { nsCOMPtr <nsIAppShellService> appShellService(do_GetService(NS_APPSHELLSERVICE_CONTRACTID)); if (!appShellService) { return NS_ERROR_FAILURE; } nsCOMPtr <nsIXULWindow> newWindow; nsCOMPtr <nsIAppShell> appShell(do_GetService(kAppShellCID)); appShellService->CreateTopLevelWindow(0, 0, chromeFlags, nsIAppShellService::SIZE_TO_CONTENT, nsIAppShellService::SIZE_TO_CONTENT, appShell, getter_AddRefs(newWindow)); if (newWindow) { newWindow->SetContextFlags(contextFlags); nsCOMPtr<nsIInterfaceRequestor> thing(do_QueryInterface(newWindow)); if (thing) { CallGetInterface(thing.get(), _retval); NS_IF_ADDREF(*_retval); } } } return NS_OK; }
NS_IMETHODIMP nsAppStartup::Quit(PRUint32 aMode) { PRUint32 ferocity = (aMode & 0xF); // Quit the application. We will asynchronously call the appshell's // Exit() method via nsAppExitEvent to allow one last pass // through any events in the queue. This guarantees a tidy cleanup. nsresult rv = NS_OK; PRBool postedExitEvent = PR_FALSE; if (mShuttingDown) return NS_OK; // If we're considering quitting, we will only do so if: if (ferocity == eConsiderQuit) { if (mConsiderQuitStopper == 0) { // there are no windows... ferocity = eAttemptQuit; } #ifdef XP_MACOSX else if (mConsiderQuitStopper == 1) { // ... or there is only a hiddenWindow left, and it's useless: nsCOMPtr<nsIAppShellService> appShell (do_GetService(NS_APPSHELLSERVICE_CONTRACTID)); // Failure shouldn't be fatal, but will abort quit attempt: if (!appShell) return NS_OK; PRBool usefulHiddenWindow; appShell->GetApplicationProvidedHiddenWindow(&usefulHiddenWindow); nsCOMPtr<nsIXULWindow> hiddenWindow; appShell->GetHiddenWindow(getter_AddRefs(hiddenWindow)); // If the one window is useful, we won't quit: if (!hiddenWindow || usefulHiddenWindow) return NS_OK; ferocity = eAttemptQuit; } #endif } nsCOMPtr<nsIObserverService> obsService; if (ferocity == eAttemptQuit || ferocity == eForceQuit) { nsCOMPtr<nsISimpleEnumerator> windowEnumerator; nsCOMPtr<nsIWindowMediator> mediator (do_GetService(NS_WINDOWMEDIATOR_CONTRACTID)); if (mediator) { mediator->GetEnumerator(nsnull, getter_AddRefs(windowEnumerator)); if (windowEnumerator) { PRBool more; while (windowEnumerator->HasMoreElements(&more), more) { nsCOMPtr<nsISupports> window; windowEnumerator->GetNext(getter_AddRefs(window)); nsCOMPtr<nsPIDOMWindow> domWindow(do_QueryInterface(window)); if (domWindow) { if (!domWindow->CanClose()) return NS_OK; } } } } mShuttingDown = PR_TRUE; if (!mRestart) { mRestart = (aMode & eRestart) != 0; gRestartMode = (aMode & 0xF0); } if (mRestart) { // Firefox-restarts reuse the process. Process start-time isn't a useful indicator of startup time PR_SetEnv(PR_smprintf("MOZ_APP_RESTART=%lld", (PRInt64) PR_Now() / PR_USEC_PER_MSEC)); } obsService = mozilla::services::GetObserverService(); if (!mAttemptingQuit) { mAttemptingQuit = PR_TRUE; #ifdef XP_MACOSX // now even the Mac wants to quit when the last window is closed ExitLastWindowClosingSurvivalArea(); #endif if (obsService) obsService->NotifyObservers(nsnull, "quit-application-granted", nsnull); } /* Enumerate through each open window and close it. It's important to do this before we forcequit because this can control whether we really quit at all. e.g. if one of these windows has an unload handler that opens a new window. Ugh. I know. */ CloseAllWindows(); if (mediator) { if (ferocity == eAttemptQuit) { ferocity = eForceQuit; // assume success /* Were we able to immediately close all windows? if not, eAttemptQuit failed. This could happen for a variety of reasons; in fact it's very likely. Perhaps we're being called from JS and the window->Close method hasn't had a chance to wrap itself up yet. So give up. We'll return (with eConsiderQuit) as the remaining windows are closed. */ mediator->GetEnumerator(nsnull, getter_AddRefs(windowEnumerator)); if (windowEnumerator) { PRBool more; while (windowEnumerator->HasMoreElements(&more), more) { /* we can't quit immediately. we'll try again as the last window finally closes. */ ferocity = eAttemptQuit; nsCOMPtr<nsISupports> window; windowEnumerator->GetNext(getter_AddRefs(window)); nsCOMPtr<nsIDOMWindowInternal> domWindow(do_QueryInterface(window)); if (domWindow) { PRBool closed = PR_FALSE; domWindow->GetClosed(&closed); if (!closed) { rv = NS_ERROR_FAILURE; break; } } } } } } } if (ferocity == eForceQuit) { // do it! // No chance of the shutdown being cancelled from here on; tell people // we're shutting down for sure while all services are still available. if (obsService) { NS_NAMED_LITERAL_STRING(shutdownStr, "shutdown"); NS_NAMED_LITERAL_STRING(restartStr, "restart"); obsService->NotifyObservers(nsnull, "quit-application", mRestart ? restartStr.get() : shutdownStr.get()); } if (!mRunning) { postedExitEvent = PR_TRUE; } else { // no matter what, make sure we send the exit event. If // worst comes to worst, we'll do a leaky shutdown but we WILL // shut down. Well, assuming that all *this* stuff works ;-). nsCOMPtr<nsIRunnable> event = new nsAppExitEvent(this); rv = NS_DispatchToCurrentThread(event); if (NS_SUCCEEDED(rv)) { postedExitEvent = PR_TRUE; } else { NS_WARNING("failed to dispatch nsAppExitEvent"); } } } // turn off the reentrancy check flag, but not if we have // more asynchronous work to do still. if (!postedExitEvent) mShuttingDown = PR_FALSE; return rv; }