summaryrefslogtreecommitdiffstats
path: root/dom/base/nsWindowRoot.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'dom/base/nsWindowRoot.cpp')
-rw-r--r--dom/base/nsWindowRoot.cpp389
1 files changed, 389 insertions, 0 deletions
diff --git a/dom/base/nsWindowRoot.cpp b/dom/base/nsWindowRoot.cpp
new file mode 100644
index 0000000000..9cc04bbbf1
--- /dev/null
+++ b/dom/base/nsWindowRoot.cpp
@@ -0,0 +1,389 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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 "mozilla/BasicEvents.h"
+#include "mozilla/EventDispatcher.h"
+#include "mozilla/EventListenerManager.h"
+#include "mozilla/StaticPrefs_browser.h"
+#include "mozilla/dom/WindowRootBinding.h"
+#include "nsCOMPtr.h"
+#include "nsWindowRoot.h"
+#include "nsPIDOMWindow.h"
+#include "nsPresContext.h"
+#include "nsLayoutCID.h"
+#include "nsContentCID.h"
+#include "nsString.h"
+#include "nsFrameLoaderOwner.h"
+#include "nsFrameLoader.h"
+#include "nsQueryActor.h"
+#include "nsGlobalWindow.h"
+#include "nsFocusManager.h"
+#include "nsIContent.h"
+#include "nsIControllers.h"
+#include "nsIController.h"
+#include "nsQueryObject.h"
+#include "xpcpublic.h"
+#include "nsCycleCollectionParticipant.h"
+#include "mozilla/dom/BrowserParent.h"
+#include "mozilla/dom/CanonicalBrowsingContext.h"
+#include "mozilla/dom/HTMLTextAreaElement.h"
+#include "mozilla/dom/HTMLInputElement.h"
+#include "mozilla/dom/JSActorService.h"
+#include "mozilla/dom/WindowGlobalParent.h"
+
+#include "nsXULElement.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+nsWindowRoot::nsWindowRoot(nsPIDOMWindowOuter* aWindow) { mWindow = aWindow; }
+
+nsWindowRoot::~nsWindowRoot() {
+ if (mListenerManager) {
+ mListenerManager->Disconnect();
+ }
+
+ JSActorService::UnregisterChromeEventTarget(this);
+}
+
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(nsWindowRoot)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsWindowRoot)
+ JSActorService::UnregisterChromeEventTarget(tmp);
+
+ NS_IMPL_CYCLE_COLLECTION_UNLINK(mWindow)
+ NS_IMPL_CYCLE_COLLECTION_UNLINK(mListenerManager)
+ NS_IMPL_CYCLE_COLLECTION_UNLINK(mParent)
+ NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsWindowRoot)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mWindow)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mListenerManager)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mParent)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsWindowRoot)
+ NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+ NS_INTERFACE_MAP_ENTRY(nsISupports)
+ NS_INTERFACE_MAP_ENTRY(nsPIWindowRoot)
+ NS_INTERFACE_MAP_ENTRY(mozilla::dom::EventTarget)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(nsWindowRoot)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(nsWindowRoot)
+
+bool nsWindowRoot::DispatchEvent(Event& aEvent, CallerType aCallerType,
+ ErrorResult& aRv) {
+ nsEventStatus status = nsEventStatus_eIgnore;
+ nsresult rv = EventDispatcher::DispatchDOMEvent(
+ static_cast<EventTarget*>(this), nullptr, &aEvent, nullptr, &status);
+ bool retval = !aEvent.DefaultPrevented(aCallerType);
+ if (NS_FAILED(rv)) {
+ aRv.Throw(rv);
+ }
+ return retval;
+}
+
+bool nsWindowRoot::ComputeDefaultWantsUntrusted(ErrorResult& aRv) {
+ return false;
+}
+
+EventListenerManager* nsWindowRoot::GetOrCreateListenerManager() {
+ if (!mListenerManager) {
+ mListenerManager =
+ new EventListenerManager(static_cast<EventTarget*>(this));
+ }
+
+ return mListenerManager;
+}
+
+EventListenerManager* nsWindowRoot::GetExistingListenerManager() const {
+ return mListenerManager;
+}
+
+void nsWindowRoot::GetEventTargetParent(EventChainPreVisitor& aVisitor) {
+ aVisitor.mCanHandle = true;
+ aVisitor.mForceContentDispatch = true; // FIXME! Bug 329119
+ // To keep mWindow alive
+ aVisitor.mItemData = static_cast<nsISupports*>(mWindow);
+ aVisitor.SetParentTarget(mParent, false);
+}
+
+nsresult nsWindowRoot::PostHandleEvent(EventChainPostVisitor& aVisitor) {
+ return NS_OK;
+}
+
+nsPIDOMWindowOuter* nsWindowRoot::GetOwnerGlobalForBindingsInternal() {
+ return mWindow;
+}
+
+nsIGlobalObject* nsWindowRoot::GetOwnerGlobal() const {
+ nsCOMPtr<nsIGlobalObject> global =
+ do_QueryInterface(mWindow->GetCurrentInnerWindow());
+ // We're still holding a ref to it, so returning the raw pointer is ok...
+ return global;
+}
+
+nsPIDOMWindowOuter* nsWindowRoot::GetWindow() { return mWindow; }
+
+nsresult nsWindowRoot::GetControllers(bool aForVisibleWindow,
+ nsIControllers** aResult) {
+ *aResult = nullptr;
+
+ // XXX: we should fix this so there's a generic interface that
+ // describes controllers, so this code would have no special
+ // knowledge of what object might have controllers.
+
+ nsFocusManager::SearchRange searchRange =
+ aForVisibleWindow ? nsFocusManager::eIncludeVisibleDescendants
+ : nsFocusManager::eIncludeAllDescendants;
+ nsCOMPtr<nsPIDOMWindowOuter> focusedWindow;
+ nsIContent* focusedContent = nsFocusManager::GetFocusedDescendant(
+ mWindow, searchRange, getter_AddRefs(focusedWindow));
+ if (focusedContent) {
+ RefPtr<nsXULElement> xulElement = nsXULElement::FromNode(focusedContent);
+ if (xulElement) {
+ ErrorResult rv;
+ *aResult = xulElement->GetControllers(rv);
+ NS_IF_ADDREF(*aResult);
+ return rv.StealNSResult();
+ }
+
+ HTMLTextAreaElement* htmlTextArea =
+ HTMLTextAreaElement::FromNode(focusedContent);
+ if (htmlTextArea) return htmlTextArea->GetControllers(aResult);
+
+ HTMLInputElement* htmlInputElement =
+ HTMLInputElement::FromNode(focusedContent);
+ if (htmlInputElement) return htmlInputElement->GetControllers(aResult);
+
+ if (focusedContent->IsEditable() && focusedWindow)
+ return focusedWindow->GetControllers(aResult);
+ } else {
+ return focusedWindow->GetControllers(aResult);
+ }
+
+ return NS_OK;
+}
+
+nsresult nsWindowRoot::GetControllerForCommand(const char* aCommand,
+ bool aForVisibleWindow,
+ nsIController** _retval) {
+ NS_ENSURE_ARG_POINTER(_retval);
+ *_retval = nullptr;
+
+ // If this is the parent process, check if a child browsing context from
+ // another process is focused, and ask if it has a controller actor that
+ // supports the command.
+ if (XRE_IsParentProcess()) {
+ nsFocusManager* fm = nsFocusManager::GetFocusManager();
+ if (!fm) {
+ return NS_ERROR_FAILURE;
+ }
+
+ // Unfortunately, messages updating the active/focus state in the focus
+ // manager don't happen fast enough in the case when switching focus between
+ // processes when clicking on a chrome UI element while a child tab is
+ // focused, so we need to check whether the focus manager thinks a child
+ // frame is focused as well.
+ nsCOMPtr<nsPIDOMWindowOuter> focusedWindow;
+ nsIContent* focusedContent = nsFocusManager::GetFocusedDescendant(
+ mWindow, nsFocusManager::eIncludeAllDescendants,
+ getter_AddRefs(focusedWindow));
+ RefPtr<nsFrameLoaderOwner> loaderOwner = do_QueryObject(focusedContent);
+ if (loaderOwner) {
+ // Only check browsing contexts if a remote frame is focused. If chrome is
+ // focused, just check the controllers directly below.
+ RefPtr<nsFrameLoader> frameLoader = loaderOwner->GetFrameLoader();
+ if (frameLoader && frameLoader->IsRemoteFrame()) {
+ // GetActiveBrowsingContextInChrome actually returns the top-level
+ // browsing context if the focus is in a child process tab, or null if
+ // the focus is in chrome.
+ BrowsingContext* focusedBC =
+ fm->GetActiveBrowsingContextInChrome()
+ ? fm->GetFocusedBrowsingContextInChrome()
+ : nullptr;
+ if (focusedBC) {
+ // At this point, it is known that a child process is focused, so ask
+ // its Controllers actor if the command is supported.
+ nsCOMPtr<nsIController> controller = do_QueryActor(
+ "Controllers", focusedBC->Canonical()->GetCurrentWindowGlobal());
+ if (controller) {
+ bool supported;
+ controller->SupportsCommand(aCommand, &supported);
+ if (supported) {
+ controller.forget(_retval);
+ return NS_OK;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ {
+ nsCOMPtr<nsIControllers> controllers;
+ GetControllers(aForVisibleWindow, getter_AddRefs(controllers));
+ if (controllers) {
+ nsCOMPtr<nsIController> controller;
+ controllers->GetControllerForCommand(aCommand,
+ getter_AddRefs(controller));
+ if (controller) {
+ controller.forget(_retval);
+ return NS_OK;
+ }
+ }
+ }
+
+ nsFocusManager::SearchRange searchRange =
+ aForVisibleWindow ? nsFocusManager::eIncludeVisibleDescendants
+ : nsFocusManager::eIncludeAllDescendants;
+ nsCOMPtr<nsPIDOMWindowOuter> focusedWindow;
+ nsFocusManager::GetFocusedDescendant(mWindow, searchRange,
+ getter_AddRefs(focusedWindow));
+ while (focusedWindow) {
+ nsCOMPtr<nsIControllers> controllers;
+ focusedWindow->GetControllers(getter_AddRefs(controllers));
+ if (controllers) {
+ nsCOMPtr<nsIController> controller;
+ controllers->GetControllerForCommand(aCommand,
+ getter_AddRefs(controller));
+ if (controller) {
+ controller.forget(_retval);
+ return NS_OK;
+ }
+ }
+
+ // XXXndeakin P3 is this casting safe?
+ nsGlobalWindowOuter* win = nsGlobalWindowOuter::Cast(focusedWindow);
+ focusedWindow = win->GetPrivateParent();
+ }
+
+ return NS_OK;
+}
+
+void nsWindowRoot::GetEnabledDisabledCommandsForControllers(
+ nsIControllers* aControllers, nsTHashSet<nsCString>& aCommandsHandled,
+ nsTArray<nsCString>& aEnabledCommands,
+ nsTArray<nsCString>& aDisabledCommands) {
+ uint32_t controllerCount;
+ aControllers->GetControllerCount(&controllerCount);
+ for (uint32_t c = 0; c < controllerCount; c++) {
+ nsCOMPtr<nsIController> controller;
+ aControllers->GetControllerAt(c, getter_AddRefs(controller));
+
+ nsCOMPtr<nsICommandController> commandController(
+ do_QueryInterface(controller));
+ if (commandController) {
+ // All of our default command controllers have 20-60 commands. Let's just
+ // leave enough space here for all of them so we probably don't need to
+ // heap-allocate.
+ AutoTArray<nsCString, 64> commands;
+ if (NS_SUCCEEDED(commandController->GetSupportedCommands(commands))) {
+ for (auto& commandStr : commands) {
+ // Use a hash to determine which commands have already been handled by
+ // earlier controllers, as the earlier controller's result should get
+ // priority.
+ if (aCommandsHandled.EnsureInserted(commandStr)) {
+ // We inserted a new entry into aCommandsHandled.
+ bool enabled = false;
+ controller->IsCommandEnabled(commandStr.get(), &enabled);
+
+ if (enabled) {
+ aEnabledCommands.AppendElement(commandStr);
+ } else {
+ aDisabledCommands.AppendElement(commandStr);
+ }
+ }
+ }
+ }
+ }
+ }
+}
+
+void nsWindowRoot::GetEnabledDisabledCommands(
+ nsTArray<nsCString>& aEnabledCommands,
+ nsTArray<nsCString>& aDisabledCommands) {
+ nsTHashSet<nsCString> commandsHandled;
+
+ nsCOMPtr<nsIControllers> controllers;
+ GetControllers(false, getter_AddRefs(controllers));
+ if (controllers) {
+ GetEnabledDisabledCommandsForControllers(
+ controllers, commandsHandled, aEnabledCommands, aDisabledCommands);
+ }
+
+ nsCOMPtr<nsPIDOMWindowOuter> focusedWindow;
+ nsFocusManager::GetFocusedDescendant(mWindow,
+ nsFocusManager::eIncludeAllDescendants,
+ getter_AddRefs(focusedWindow));
+ while (focusedWindow) {
+ focusedWindow->GetControllers(getter_AddRefs(controllers));
+ if (controllers) {
+ GetEnabledDisabledCommandsForControllers(
+ controllers, commandsHandled, aEnabledCommands, aDisabledCommands);
+ }
+
+ nsGlobalWindowOuter* win = nsGlobalWindowOuter::Cast(focusedWindow);
+ focusedWindow = win->GetPrivateParent();
+ }
+}
+
+already_AddRefed<nsINode> nsWindowRoot::GetPopupNode() {
+ nsCOMPtr<nsINode> popupNode = do_QueryReferent(mPopupNode);
+ return popupNode.forget();
+}
+
+void nsWindowRoot::SetPopupNode(nsINode* aNode) {
+ mPopupNode = do_GetWeakReference(aNode);
+}
+
+nsIGlobalObject* nsWindowRoot::GetParentObject() {
+ return xpc::NativeGlobal(xpc::PrivilegedJunkScope());
+}
+
+JSObject* nsWindowRoot::WrapObject(JSContext* aCx,
+ JS::Handle<JSObject*> aGivenProto) {
+ return mozilla::dom::WindowRoot_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+void nsWindowRoot::AddBrowser(nsIRemoteTab* aBrowser) {
+ nsWeakPtr weakBrowser = do_GetWeakReference(aBrowser);
+ mWeakBrowsers.Insert(weakBrowser);
+}
+
+void nsWindowRoot::RemoveBrowser(nsIRemoteTab* aBrowser) {
+ nsWeakPtr weakBrowser = do_GetWeakReference(aBrowser);
+ mWeakBrowsers.Remove(weakBrowser);
+}
+
+void nsWindowRoot::EnumerateBrowsers(BrowserEnumerator aEnumFunc, void* aArg) {
+ // Collect strong references to all browsers in a separate array in
+ // case aEnumFunc alters mWeakBrowsers.
+ nsTArray<nsCOMPtr<nsIRemoteTab>> remoteTabs;
+ for (const auto& key : mWeakBrowsers) {
+ nsCOMPtr<nsIRemoteTab> remoteTab(do_QueryReferent(key));
+ if (remoteTab) {
+ remoteTabs.AppendElement(remoteTab);
+ }
+ }
+
+ for (uint32_t i = 0; i < remoteTabs.Length(); ++i) {
+ aEnumFunc(remoteTabs[i], aArg);
+ }
+}
+
+///////////////////////////////////////////////////////////////////////////////////
+
+already_AddRefed<EventTarget> NS_NewWindowRoot(nsPIDOMWindowOuter* aWindow) {
+ nsCOMPtr<EventTarget> result = new nsWindowRoot(aWindow);
+
+ RefPtr<JSActorService> wasvc = JSActorService::GetSingleton();
+ wasvc->RegisterChromeEventTarget(result);
+
+ return result.forget();
+}