diff options
Diffstat (limited to 'xpfe/appshell/nsWebShellWindow.cpp')
| -rw-r--r-- | xpfe/appshell/nsWebShellWindow.cpp | 911 |
1 files changed, 911 insertions, 0 deletions
diff --git a/xpfe/appshell/nsWebShellWindow.cpp b/xpfe/appshell/nsWebShellWindow.cpp new file mode 100644 index 000000000..288d94759 --- /dev/null +++ b/xpfe/appshell/nsWebShellWindow.cpp @@ -0,0 +1,911 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + + +#include "nsWebShellWindow.h" + +#include "nsLayoutCID.h" +#include "nsContentCID.h" +#include "nsIWeakReference.h" +#include "nsIContentViewer.h" +#include "nsIComponentManager.h" +#include "nsIServiceManager.h" +#include "nsIURL.h" +#include "nsIIOService.h" +#include "nsIURL.h" +#include "nsNetCID.h" +#include "nsIStringBundle.h" +#include "nsReadableUtils.h" + +#include "nsContentUtils.h" +#include "nsEscape.h" +#include "nsPIDOMWindow.h" +#include "nsIWebNavigation.h" +#include "nsIWindowWatcher.h" + +#include "nsIDOMXULElement.h" + +#include "nsWidgetInitData.h" +#include "nsWidgetsCID.h" +#include "nsIWidget.h" +#include "nsIWidgetListener.h" + +#include "nsIDOMCharacterData.h" +#include "nsIDOMNodeList.h" + +#include "nsITimer.h" +#include "nsXULPopupManager.h" + + +#include "nsIDOMXULDocument.h" + +#include "nsFocusManager.h" + +#include "nsIWebProgress.h" +#include "nsIWebProgressListener.h" + +#include "nsIDocument.h" +#include "nsIDOMDocument.h" +#include "nsIDOMNode.h" +#include "nsIDOMElement.h" +#include "nsIDocumentLoaderFactory.h" +#include "nsIObserverService.h" +#include "prprf.h" + +#include "nsIScreenManager.h" +#include "nsIScreen.h" + +#include "nsIContent.h" // for menus +#include "nsIScriptSecurityManager.h" + +// For calculating size +#include "nsIPresShell.h" +#include "nsPresContext.h" + +#include "nsIBaseWindow.h" +#include "nsIDocShellTreeItem.h" + +#include "mozilla/Attributes.h" +#include "mozilla/DebugOnly.h" +#include "mozilla/MouseEvents.h" + +#include "nsPIWindowRoot.h" + +#ifdef XP_MACOSX +#include "nsINativeMenuService.h" +#define USE_NATIVE_MENUS +#endif + +using namespace mozilla; +using namespace mozilla::dom; + +/* Define Class IDs */ +static NS_DEFINE_CID(kWindowCID, NS_WINDOW_CID); + +#define SIZE_PERSISTENCE_TIMEOUT 500 // msec + +nsWebShellWindow::nsWebShellWindow(uint32_t aChromeFlags) + : nsXULWindow(aChromeFlags) + , mSPTimerLock("nsWebShellWindow.mSPTimerLock") + , mWidgetListenerDelegate(this) +{ +} + +nsWebShellWindow::~nsWebShellWindow() +{ + MutexAutoLock lock(mSPTimerLock); + if (mSPTimer) + mSPTimer->Cancel(); +} + +NS_IMPL_ADDREF_INHERITED(nsWebShellWindow, nsXULWindow) +NS_IMPL_RELEASE_INHERITED(nsWebShellWindow, nsXULWindow) + +NS_INTERFACE_MAP_BEGIN(nsWebShellWindow) + NS_INTERFACE_MAP_ENTRY(nsIWebProgressListener) +NS_INTERFACE_MAP_END_INHERITING(nsXULWindow) + +nsresult nsWebShellWindow::Initialize(nsIXULWindow* aParent, + nsIXULWindow* aOpener, + nsIURI* aUrl, + int32_t aInitialWidth, + int32_t aInitialHeight, + bool aIsHiddenWindow, + nsITabParent *aOpeningTab, + mozIDOMWindowProxy *aOpenerWindow, + nsWidgetInitData& widgetInitData) +{ + nsresult rv; + nsCOMPtr<nsIWidget> parentWidget; + + mIsHiddenWindow = aIsHiddenWindow; + + int32_t initialX = 0, initialY = 0; + nsCOMPtr<nsIBaseWindow> base(do_QueryInterface(aOpener)); + if (base) { + rv = base->GetPositionAndSize(&mOpenerScreenRect.x, + &mOpenerScreenRect.y, + &mOpenerScreenRect.width, + &mOpenerScreenRect.height); + if (NS_FAILED(rv)) { + mOpenerScreenRect.SetEmpty(); + } else { + double scale; + if (NS_SUCCEEDED(base->GetUnscaledDevicePixelsPerCSSPixel(&scale))) { + mOpenerScreenRect.x = NSToIntRound(mOpenerScreenRect.x / scale); + mOpenerScreenRect.y = NSToIntRound(mOpenerScreenRect.y / scale); + mOpenerScreenRect.width = NSToIntRound(mOpenerScreenRect.width / scale); + mOpenerScreenRect.height = NSToIntRound(mOpenerScreenRect.height / scale); + } + initialX = mOpenerScreenRect.x; + initialY = mOpenerScreenRect.y; + ConstrainToOpenerScreen(&initialX, &initialY); + } + } + + // XXX: need to get the default window size from prefs... + // Doesn't come from prefs... will come from CSS/XUL/RDF + DesktopIntRect deskRect(initialX, initialY, aInitialWidth, aInitialHeight); + + // Create top level window + mWindow = do_CreateInstance(kWindowCID, &rv); + if (NS_OK != rv) { + return rv; + } + + /* This next bit is troublesome. We carry two different versions of a pointer + to our parent window. One is the parent window's widget, which is passed + to our own widget. The other is a weak reference we keep here to our + parent WebShellWindow. The former is useful to the widget, and we can't + trust its treatment of the parent reference because they're platform- + specific. The latter is useful to this class. + A better implementation would be one in which the parent keeps strong + references to its children and closes them before it allows itself + to be closed. This would mimic the behaviour of OSes that support + top-level child windows in OSes that do not. Later. + */ + nsCOMPtr<nsIBaseWindow> parentAsWin(do_QueryInterface(aParent)); + if (parentAsWin) { + parentAsWin->GetMainWidget(getter_AddRefs(parentWidget)); + mParentWindow = do_GetWeakReference(aParent); + } + + mWindow->SetWidgetListener(&mWidgetListenerDelegate); + rv = mWindow->Create((nsIWidget *)parentWidget, // Parent nsIWidget + nullptr, // Native parent widget + deskRect, // Widget dimensions + &widgetInitData); // Widget initialization data + NS_ENSURE_SUCCESS(rv, rv); + + LayoutDeviceIntRect r = mWindow->GetClientBounds(); + // Match the default background color of content. Important on windows + // since we no longer use content child widgets. + mWindow->SetBackgroundColor(NS_RGB(255,255,255)); + + // Create web shell + mDocShell = do_CreateInstance("@mozilla.org/docshell;1"); + NS_ENSURE_TRUE(mDocShell, NS_ERROR_FAILURE); + + mDocShell->SetOpener(aOpeningTab); + + // Make sure to set the item type on the docshell _before_ calling + // Create() so it knows what type it is. + nsCOMPtr<nsIDocShellTreeItem> docShellAsItem(do_QueryInterface(mDocShell)); + NS_ENSURE_TRUE(docShellAsItem, NS_ERROR_FAILURE); + NS_ENSURE_SUCCESS(EnsureChromeTreeOwner(), NS_ERROR_FAILURE); + + docShellAsItem->SetTreeOwner(mChromeTreeOwner); + docShellAsItem->SetItemType(nsIDocShellTreeItem::typeChrome); + + r.x = r.y = 0; + nsCOMPtr<nsIBaseWindow> docShellAsWin(do_QueryInterface(mDocShell)); + NS_ENSURE_SUCCESS(docShellAsWin->InitWindow(nullptr, mWindow, + r.x, r.y, r.width, r.height), NS_ERROR_FAILURE); + NS_ENSURE_SUCCESS(docShellAsWin->Create(), NS_ERROR_FAILURE); + + // Attach a WebProgress listener.during initialization... + nsCOMPtr<nsIWebProgress> webProgress(do_GetInterface(mDocShell, &rv)); + if (webProgress) { + webProgress->AddProgressListener(this, nsIWebProgress::NOTIFY_STATE_NETWORK); + } + + if (aOpenerWindow) { + nsPIDOMWindowOuter* window = mDocShell->GetWindow(); + MOZ_ASSERT(window); + window->SetOpenerWindow(nsPIDOMWindowOuter::From(aOpenerWindow), true); + } + + // Eagerly create an about:blank content viewer with the right principal here, + // rather than letting it happening in the upcoming call to + // SetInitialPrincipalToSubject. This avoids creating the about:blank document + // and then blowing it away with a second one, which can cause problems for the + // top-level chrome window case. See bug 789773. + // Note that we don't accept expanded principals here, similar to + // SetInitialPrincipalToSubject. + if (nsContentUtils::IsInitialized()) { // Sometimes this happens really early See bug 793370. + MOZ_ASSERT(mDocShell->ItemType() == nsIDocShellTreeItem::typeChrome); + nsCOMPtr<nsIPrincipal> principal = nsContentUtils::SubjectPrincipalOrSystemIfNativeCaller(); + if (nsContentUtils::IsExpandedPrincipal(principal)) { + principal = nullptr; + } + rv = mDocShell->CreateAboutBlankContentViewer(principal); + NS_ENSURE_SUCCESS(rv, rv); + nsCOMPtr<nsIDocument> doc = mDocShell->GetDocument(); + NS_ENSURE_TRUE(!!doc, NS_ERROR_FAILURE); + doc->SetIsInitialDocument(true); + } + + if (nullptr != aUrl) { + nsCString tmpStr; + + rv = aUrl->GetSpec(tmpStr); + if (NS_FAILED(rv)) return rv; + + NS_ConvertUTF8toUTF16 urlString(tmpStr); + nsCOMPtr<nsIWebNavigation> webNav(do_QueryInterface(mDocShell)); + NS_ENSURE_TRUE(webNav, NS_ERROR_FAILURE); + rv = webNav->LoadURI(urlString.get(), + nsIWebNavigation::LOAD_FLAGS_NONE, + nullptr, + nullptr, + nullptr); + NS_ENSURE_SUCCESS(rv, rv); + } + + return rv; +} + +nsIPresShell* +nsWebShellWindow::GetPresShell() +{ + if (!mDocShell) + return nullptr; + + return mDocShell->GetPresShell(); +} + +bool +nsWebShellWindow::WindowMoved(nsIWidget* aWidget, int32_t x, int32_t y) +{ + nsXULPopupManager* pm = nsXULPopupManager::GetInstance(); + if (pm) { + nsCOMPtr<nsPIDOMWindowOuter> window = + mDocShell ? mDocShell->GetWindow() : nullptr; + pm->AdjustPopupsOnWindowChange(window); + } + + // Notify all tabs that the widget moved. + if (mDocShell && mDocShell->GetWindow()) { + nsCOMPtr<EventTarget> eventTarget = mDocShell->GetWindow()->GetTopWindowRoot(); + nsContentUtils::DispatchChromeEvent(mDocShell->GetDocument(), + eventTarget, + NS_LITERAL_STRING("MozUpdateWindowPos"), + false, false, nullptr); + } + + // Persist position, but not immediately, in case this OS is firing + // repeated move events as the user drags the window + SetPersistenceTimer(PAD_POSITION); + return false; +} + +bool +nsWebShellWindow::WindowResized(nsIWidget* aWidget, int32_t aWidth, int32_t aHeight) +{ + nsCOMPtr<nsIBaseWindow> shellAsWin(do_QueryInterface(mDocShell)); + if (shellAsWin) { + shellAsWin->SetPositionAndSize(0, 0, aWidth, aHeight, 0); + } + // Persist size, but not immediately, in case this OS is firing + // repeated size events as the user drags the sizing handle + if (!IsLocked()) + SetPersistenceTimer(PAD_POSITION | PAD_SIZE | PAD_MISC); + return true; +} + +bool +nsWebShellWindow::RequestWindowClose(nsIWidget* aWidget) +{ + // Maintain a reference to this as it is about to get destroyed. + nsCOMPtr<nsIXULWindow> xulWindow(this); + + nsCOMPtr<nsPIDOMWindowOuter> window(mDocShell ? mDocShell->GetWindow() : nullptr); + nsCOMPtr<EventTarget> eventTarget = do_QueryInterface(window); + + nsCOMPtr<nsIPresShell> presShell = mDocShell->GetPresShell(); + if (!presShell) { + mozilla::DebugOnly<bool> dying; + MOZ_ASSERT(NS_SUCCEEDED(mDocShell->IsBeingDestroyed(&dying)) && dying, + "No presShell, but window is not being destroyed"); + } else if (eventTarget) { + RefPtr<nsPresContext> presContext = presShell->GetPresContext(); + + nsEventStatus status = nsEventStatus_eIgnore; + WidgetMouseEvent event(true, eWindowClose, nullptr, + WidgetMouseEvent::eReal); + if (NS_SUCCEEDED(eventTarget->DispatchDOMEvent(&event, nullptr, presContext, &status)) && + status == nsEventStatus_eConsumeNoDefault) + return false; + } + + Destroy(); + return false; +} + +void +nsWebShellWindow::SizeModeChanged(nsSizeMode sizeMode) +{ + // An alwaysRaised (or higher) window will hide any newly opened normal + // browser windows, so here we just drop a raised window to the normal + // zlevel if it's maximized. We make no provision for automatically + // re-raising it when restored. + if (sizeMode == nsSizeMode_Maximized || sizeMode == nsSizeMode_Fullscreen) { + uint32_t zLevel; + GetZLevel(&zLevel); + if (zLevel > nsIXULWindow::normalZ) + SetZLevel(nsIXULWindow::normalZ); + } + mWindow->SetSizeMode(sizeMode); + + // Persist mode, but not immediately, because in many (all?) + // cases this will merge with the similar call in NS_SIZE and + // write the attribute values only once. + SetPersistenceTimer(PAD_MISC); + nsCOMPtr<nsPIDOMWindowOuter> ourWindow = + mDocShell ? mDocShell->GetWindow() : nullptr; + if (ourWindow) { + MOZ_ASSERT(ourWindow->IsOuterWindow()); + + // Ensure that the fullscreen state is synchronized between + // the widget and the outer window object. + if (sizeMode == nsSizeMode_Fullscreen) { + ourWindow->SetFullScreen(true); + } + else if (sizeMode != nsSizeMode_Minimized) { + if (ourWindow->GetFullScreen()) { + // The first SetFullscreenInternal call below ensures that we do + // not trigger any fullscreen transition even if the window was + // put in fullscreen only for the Fullscreen API. The second + // SetFullScreen call ensures that the window really exit from + // fullscreen even if it entered fullscreen for both Fullscreen + // Mode and Fullscreen API. + ourWindow->SetFullscreenInternal(FullscreenReason::ForForceExitFullscreen, false); + ourWindow->SetFullScreen(false); + } + } + + // And always fire a user-defined sizemodechange event on the window + ourWindow->DispatchCustomEvent(NS_LITERAL_STRING("sizemodechange")); + } + + nsIPresShell* presShell; + if ((presShell = GetPresShell())) { + presShell->GetPresContext()->SizeModeChanged(sizeMode); + } + + // Note the current implementation of SetSizeMode just stores + // the new state; it doesn't actually resize. So here we store + // the state and pass the event on to the OS. The day is coming + // when we'll handle the event here, and the return result will + // then need to be different. +} + +void +nsWebShellWindow::UIResolutionChanged() +{ + nsCOMPtr<nsPIDOMWindowOuter> ourWindow = + mDocShell ? mDocShell->GetWindow() : nullptr; + if (ourWindow) { + MOZ_ASSERT(ourWindow->IsOuterWindow()); + ourWindow->DispatchCustomEvent(NS_LITERAL_STRING("resolutionchange")); + } +} + +void +nsWebShellWindow::FullscreenChanged(bool aInFullscreen) +{ + if (mDocShell) { + if (nsCOMPtr<nsPIDOMWindowOuter> ourWindow = mDocShell->GetWindow()) { + ourWindow->FinishFullscreenChange(aInFullscreen); + } + } +} + +void +nsWebShellWindow::OSToolbarButtonPressed() +{ + // Keep a reference as setting the chrome flags can fire events. + nsCOMPtr<nsIXULWindow> xulWindow(this); + + // rjc: don't use "nsIWebBrowserChrome::CHROME_EXTRA" + // due to components with multiple sidebar components + // (such as Mail/News, Addressbook, etc)... and frankly, + // Mac IE, OmniWeb, and other Mac OS X apps all work this way + uint32_t chromeMask = (nsIWebBrowserChrome::CHROME_TOOLBAR | + nsIWebBrowserChrome::CHROME_LOCATIONBAR | + nsIWebBrowserChrome::CHROME_PERSONAL_TOOLBAR); + + nsCOMPtr<nsIWebBrowserChrome> wbc(do_GetInterface(xulWindow)); + if (!wbc) + return; + + uint32_t chromeFlags, newChromeFlags = 0; + wbc->GetChromeFlags(&chromeFlags); + newChromeFlags = chromeFlags & chromeMask; + if (!newChromeFlags) chromeFlags |= chromeMask; + else chromeFlags &= (~newChromeFlags); + wbc->SetChromeFlags(chromeFlags); +} + +bool +nsWebShellWindow::ZLevelChanged(bool aImmediate, nsWindowZ *aPlacement, + nsIWidget* aRequestBelow, nsIWidget** aActualBelow) +{ + if (aActualBelow) + *aActualBelow = nullptr; + + return ConstrainToZLevel(aImmediate, aPlacement, aRequestBelow, aActualBelow); +} + +void +nsWebShellWindow::WindowActivated() +{ + nsCOMPtr<nsIXULWindow> xulWindow(this); + + // focusing the window could cause it to close, so keep a reference to it + nsCOMPtr<nsPIDOMWindowOuter> window = mDocShell ? mDocShell->GetWindow() : nullptr; + nsCOMPtr<nsIFocusManager> fm = do_GetService(FOCUSMANAGER_CONTRACTID); + if (fm && window) + fm->WindowRaised(window); + + if (mChromeLoaded) { + PersistentAttributesDirty(PAD_POSITION | PAD_SIZE | PAD_MISC); + SavePersistentAttributes(); + } +} + +void +nsWebShellWindow::WindowDeactivated() +{ + nsCOMPtr<nsIXULWindow> xulWindow(this); + + nsCOMPtr<nsPIDOMWindowOuter> window = + mDocShell ? mDocShell->GetWindow() : nullptr; + nsCOMPtr<nsIFocusManager> fm = do_GetService(FOCUSMANAGER_CONTRACTID); + if (fm && window) + fm->WindowLowered(window); +} + +#ifdef USE_NATIVE_MENUS +static void LoadNativeMenus(nsIDOMDocument *aDOMDoc, nsIWidget *aParentWindow) +{ + nsCOMPtr<nsINativeMenuService> nms = do_GetService("@mozilla.org/widget/nativemenuservice;1"); + if (!nms) { + return; + } + + // Find the menubar tag (if there is more than one, we ignore all but + // the first). + nsCOMPtr<nsIDOMNodeList> menubarElements; + aDOMDoc->GetElementsByTagNameNS(NS_LITERAL_STRING("http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"), + NS_LITERAL_STRING("menubar"), + getter_AddRefs(menubarElements)); + + nsCOMPtr<nsIDOMNode> menubarNode; + if (menubarElements) + menubarElements->Item(0, getter_AddRefs(menubarNode)); + + if (menubarNode) { + nsCOMPtr<nsIContent> menubarContent(do_QueryInterface(menubarNode)); + nms->CreateNativeMenuBar(aParentWindow, menubarContent); + } else { + nms->CreateNativeMenuBar(aParentWindow, nullptr); + } +} +#endif + +namespace mozilla { + +class WebShellWindowTimerCallback final : public nsITimerCallback +{ +public: + explicit WebShellWindowTimerCallback(nsWebShellWindow* aWindow) + : mWindow(aWindow) + {} + + NS_DECL_THREADSAFE_ISUPPORTS + + NS_IMETHOD Notify(nsITimer* aTimer) override + { + // Although this object participates in a refcount cycle (this -> mWindow + // -> mSPTimer -> this), mSPTimer is a one-shot timer and releases this + // after it fires. So we don't need to release mWindow here. + + mWindow->FirePersistenceTimer(); + return NS_OK; + } + +private: + ~WebShellWindowTimerCallback() {} + + RefPtr<nsWebShellWindow> mWindow; +}; + +NS_IMPL_ISUPPORTS(WebShellWindowTimerCallback, nsITimerCallback) + +} // namespace mozilla + +void +nsWebShellWindow::SetPersistenceTimer(uint32_t aDirtyFlags) +{ + MutexAutoLock lock(mSPTimerLock); + if (!mSPTimer) { + mSPTimer = do_CreateInstance("@mozilla.org/timer;1"); + if (!mSPTimer) { + NS_WARNING("Couldn't create @mozilla.org/timer;1 instance?"); + return; + } + } + + RefPtr<WebShellWindowTimerCallback> callback = + new WebShellWindowTimerCallback(this); + mSPTimer->InitWithCallback(callback, SIZE_PERSISTENCE_TIMEOUT, + nsITimer::TYPE_ONE_SHOT); + + PersistentAttributesDirty(aDirtyFlags); +} + +void +nsWebShellWindow::FirePersistenceTimer() +{ + MutexAutoLock lock(mSPTimerLock); + SavePersistentAttributes(); +} + + +//---------------------------------------- +// nsIWebProgessListener implementation +//---------------------------------------- +NS_IMETHODIMP +nsWebShellWindow::OnProgressChange(nsIWebProgress *aProgress, + nsIRequest *aRequest, + int32_t aCurSelfProgress, + int32_t aMaxSelfProgress, + int32_t aCurTotalProgress, + int32_t aMaxTotalProgress) +{ + NS_NOTREACHED("notification excluded in AddProgressListener(...)"); + return NS_OK; +} + +NS_IMETHODIMP +nsWebShellWindow::OnStateChange(nsIWebProgress *aProgress, + nsIRequest *aRequest, + uint32_t aStateFlags, + nsresult aStatus) +{ + // If the notification is not about a document finishing, then just + // ignore it... + if (!(aStateFlags & nsIWebProgressListener::STATE_STOP) || + !(aStateFlags & nsIWebProgressListener::STATE_IS_NETWORK)) { + return NS_OK; + } + + if (mChromeLoaded) + return NS_OK; + + // If this document notification is for a frame then ignore it... + nsCOMPtr<mozIDOMWindowProxy> eventWin; + aProgress->GetDOMWindow(getter_AddRefs(eventWin)); + auto* eventPWin = nsPIDOMWindowOuter::From(eventWin); + if (eventPWin) { + nsPIDOMWindowOuter *rootPWin = eventPWin->GetPrivateRoot(); + if (eventPWin != rootPWin) + return NS_OK; + } + + mChromeLoaded = true; + mLockedUntilChromeLoad = false; + +#ifdef USE_NATIVE_MENUS + /////////////////////////////// + // Find the Menubar DOM and Load the menus, hooking them up to the loaded commands + /////////////////////////////// + nsCOMPtr<nsIContentViewer> cv; + mDocShell->GetContentViewer(getter_AddRefs(cv)); + if (cv) { + nsCOMPtr<nsIDOMDocument> menubarDOMDoc(do_QueryInterface(cv->GetDocument())); + if (menubarDOMDoc) + LoadNativeMenus(menubarDOMDoc, mWindow); + } +#endif // USE_NATIVE_MENUS + + OnChromeLoaded(); + LoadContentAreas(); + + return NS_OK; +} + +NS_IMETHODIMP +nsWebShellWindow::OnLocationChange(nsIWebProgress *aProgress, + nsIRequest *aRequest, + nsIURI *aURI, + uint32_t aFlags) +{ + NS_NOTREACHED("notification excluded in AddProgressListener(...)"); + return NS_OK; +} + +NS_IMETHODIMP +nsWebShellWindow::OnStatusChange(nsIWebProgress* aWebProgress, + nsIRequest* aRequest, + nsresult aStatus, + const char16_t* aMessage) +{ + NS_NOTREACHED("notification excluded in AddProgressListener(...)"); + return NS_OK; +} + +NS_IMETHODIMP +nsWebShellWindow::OnSecurityChange(nsIWebProgress *aWebProgress, + nsIRequest *aRequest, + uint32_t state) +{ + NS_NOTREACHED("notification excluded in AddProgressListener(...)"); + return NS_OK; +} + + +//---------------------------------------- + +// if the main document URL specified URLs for any content areas, start them loading +void nsWebShellWindow::LoadContentAreas() { + + nsAutoString searchSpec; + + // fetch the chrome document URL + nsCOMPtr<nsIContentViewer> contentViewer; + // yes, it's possible for the docshell to be null even this early + // see bug 57514. + if (mDocShell) + mDocShell->GetContentViewer(getter_AddRefs(contentViewer)); + if (contentViewer) { + nsIDocument* doc = contentViewer->GetDocument(); + if (doc) { + nsIURI* mainURL = doc->GetDocumentURI(); + + nsCOMPtr<nsIURL> url = do_QueryInterface(mainURL); + if (url) { + nsAutoCString search; + url->GetQuery(search); + + AppendUTF8toUTF16(search, searchSpec); + } + } + } + + // content URLs are specified in the search part of the URL + // as <contentareaID>=<escapedURL>[;(repeat)] + if (!searchSpec.IsEmpty()) { + int32_t begPos, + eqPos, + endPos; + nsString contentAreaID, + contentURL; + char *urlChar; + nsresult rv; + for (endPos = 0; endPos < (int32_t)searchSpec.Length(); ) { + // extract contentAreaID and URL substrings + begPos = endPos; + eqPos = searchSpec.FindChar('=', begPos); + if (eqPos < 0) + break; + + endPos = searchSpec.FindChar(';', eqPos); + if (endPos < 0) + endPos = searchSpec.Length(); + searchSpec.Mid(contentAreaID, begPos, eqPos-begPos); + searchSpec.Mid(contentURL, eqPos+1, endPos-eqPos-1); + endPos++; + + // see if we have a docshell with a matching contentAreaID + nsCOMPtr<nsIDocShellTreeItem> content; + rv = GetContentShellById(contentAreaID.get(), getter_AddRefs(content)); + if (NS_SUCCEEDED(rv) && content) { + nsCOMPtr<nsIWebNavigation> webNav(do_QueryInterface(content)); + if (webNav) { + urlChar = ToNewCString(contentURL); + if (urlChar) { + nsUnescape(urlChar); + contentURL.AssignWithConversion(urlChar); + webNav->LoadURI(contentURL.get(), + nsIWebNavigation::LOAD_FLAGS_NONE, + nullptr, + nullptr, + nullptr); + free(urlChar); + } + } + } + } + } +} + +/** + * ExecuteCloseHandler - Run the close handler, if any. + * @return true iff we found a close handler to run. + */ +bool nsWebShellWindow::ExecuteCloseHandler() +{ + /* If the event handler closes this window -- a likely scenario -- + things get deleted out of order without this death grip. + (The problem may be the death grip in nsWindow::windowProc, + which forces this window's widget to remain alive longer + than it otherwise would.) */ + nsCOMPtr<nsIXULWindow> kungFuDeathGrip(this); + + nsCOMPtr<EventTarget> eventTarget; + if (mDocShell) { + eventTarget = do_QueryInterface(mDocShell->GetWindow()); + } + + if (eventTarget) { + nsCOMPtr<nsIContentViewer> contentViewer; + mDocShell->GetContentViewer(getter_AddRefs(contentViewer)); + if (contentViewer) { + RefPtr<nsPresContext> presContext; + contentViewer->GetPresContext(getter_AddRefs(presContext)); + + nsEventStatus status = nsEventStatus_eIgnore; + WidgetMouseEvent event(true, eWindowClose, nullptr, + WidgetMouseEvent::eReal); + + nsresult rv = + eventTarget->DispatchDOMEvent(&event, nullptr, presContext, &status); + if (NS_SUCCEEDED(rv) && status == nsEventStatus_eConsumeNoDefault) + return true; + // else fall through and return false + } + } + + return false; +} // ExecuteCloseHandler + +void nsWebShellWindow::ConstrainToOpenerScreen(int32_t* aX, int32_t* aY) +{ + if (mOpenerScreenRect.IsEmpty()) { + *aX = *aY = 0; + return; + } + + int32_t left, top, width, height; + // Constrain initial positions to the same screen as opener + nsCOMPtr<nsIScreenManager> screenmgr = do_GetService("@mozilla.org/gfx/screenmanager;1"); + if (screenmgr) { + nsCOMPtr<nsIScreen> screen; + screenmgr->ScreenForRect(mOpenerScreenRect.x, mOpenerScreenRect.y, + mOpenerScreenRect.width, mOpenerScreenRect.height, + getter_AddRefs(screen)); + if (screen) { + screen->GetAvailRectDisplayPix(&left, &top, &width, &height); + if (*aX < left || *aX > left + width) { + *aX = left; + } + if (*aY < top || *aY > top + height) { + *aY = top; + } + } + } +} + +// nsIBaseWindow +NS_IMETHODIMP nsWebShellWindow::Destroy() +{ + nsresult rv; + nsCOMPtr<nsIWebProgress> webProgress(do_GetInterface(mDocShell, &rv)); + if (webProgress) { + webProgress->RemoveProgressListener(this); + } + + nsCOMPtr<nsIXULWindow> kungFuDeathGrip(this); + { + MutexAutoLock lock(mSPTimerLock); + if (mSPTimer) { + mSPTimer->Cancel(); + SavePersistentAttributes(); + mSPTimer = nullptr; + } + } + return nsXULWindow::Destroy(); +} + +nsIXULWindow* +nsWebShellWindow::WidgetListenerDelegate::GetXULWindow() +{ + return mWebShellWindow->GetXULWindow(); +} + +nsIPresShell* +nsWebShellWindow::WidgetListenerDelegate::GetPresShell() +{ + return mWebShellWindow->GetPresShell(); +} + +bool +nsWebShellWindow::WidgetListenerDelegate::WindowMoved( + nsIWidget* aWidget, int32_t aX, int32_t aY) +{ + RefPtr<nsWebShellWindow> holder = mWebShellWindow; + return holder->WindowMoved(aWidget, aX, aY); +} + +bool +nsWebShellWindow::WidgetListenerDelegate::WindowResized( + nsIWidget* aWidget, int32_t aWidth, int32_t aHeight) +{ + RefPtr<nsWebShellWindow> holder = mWebShellWindow; + return holder->WindowResized(aWidget, aWidth, aHeight); +} + +bool +nsWebShellWindow::WidgetListenerDelegate::RequestWindowClose(nsIWidget* aWidget) +{ + RefPtr<nsWebShellWindow> holder = mWebShellWindow; + return holder->RequestWindowClose(aWidget); +} + +void +nsWebShellWindow::WidgetListenerDelegate::SizeModeChanged(nsSizeMode aSizeMode) +{ + RefPtr<nsWebShellWindow> holder = mWebShellWindow; + holder->SizeModeChanged(aSizeMode); +} + +void +nsWebShellWindow::WidgetListenerDelegate::UIResolutionChanged() +{ + RefPtr<nsWebShellWindow> holder = mWebShellWindow; + holder->UIResolutionChanged(); +} + +void +nsWebShellWindow::WidgetListenerDelegate::FullscreenChanged(bool aInFullscreen) +{ + RefPtr<nsWebShellWindow> holder = mWebShellWindow; + holder->FullscreenChanged(aInFullscreen); +} + +void +nsWebShellWindow::WidgetListenerDelegate::OSToolbarButtonPressed() +{ + RefPtr<nsWebShellWindow> holder = mWebShellWindow; + holder->OSToolbarButtonPressed(); +} + +bool +nsWebShellWindow::WidgetListenerDelegate::ZLevelChanged( + bool aImmediate, nsWindowZ *aPlacement, nsIWidget* aRequestBelow, + nsIWidget** aActualBelow) +{ + RefPtr<nsWebShellWindow> holder = mWebShellWindow; + return holder->ZLevelChanged(aImmediate, + aPlacement, + aRequestBelow, + aActualBelow); +} + +void +nsWebShellWindow::WidgetListenerDelegate::WindowActivated() +{ + RefPtr<nsWebShellWindow> holder = mWebShellWindow; + holder->WindowActivated(); +} + +void +nsWebShellWindow::WidgetListenerDelegate::WindowDeactivated() +{ + RefPtr<nsWebShellWindow> holder = mWebShellWindow; + holder->WindowDeactivated(); +} |