Add m-esr52 at 52.6.0

1 files changed, 495 insertions, 0 deletions

diff --git a/xpfe/appshell/nsAppShellWindowEnumerator.cpp b/xpfe/appshell/nsAppShellWindowEnumerator.cpp
new file mode 100644
index 000000000..dc5fc120a
--- /dev/null
+++ b/xpfe/appshell/nsAppShellWindowEnumerator.cpp
@@ -0,0 +1,495 @@
+/* -*- 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 "nsAppShellWindowEnumerator.h"
+
+#include "nsIContentViewer.h"
+#include "nsIDocShell.h"
+#include "nsIDocument.h"
+#include "nsIDOMDocument.h"
+#include "nsIDOMElement.h"
+#include "nsIDOMWindow.h"
+#include "nsIFactory.h"
+#include "nsIInterfaceRequestor.h"
+#include "nsIInterfaceRequestorUtils.h"
+#include "nsIXULWindow.h"
+
+#include "nsWindowMediator.h"
+
+//
+// static helper functions
+//
+
+static nsCOMPtr<nsIDOMNode> GetDOMNodeFromDocShell(nsIDocShell *aShell);
+static void GetAttribute(nsIXULWindow *inWindow, const nsAString &inAttribute,
+                         nsAString &outValue);
+static void GetWindowType(nsIXULWindow* inWindow, nsString &outType);
+
+nsCOMPtr<nsIDOMNode> GetDOMNodeFromDocShell(nsIDocShell *aShell)
+{
+  nsCOMPtr<nsIDOMNode> node;
+
+  nsCOMPtr<nsIContentViewer> cv;
+  aShell->GetContentViewer(getter_AddRefs(cv));
+  if (cv) {
+    nsCOMPtr<nsIDOMDocument> domdoc(do_QueryInterface(cv->GetDocument()));
+    if (domdoc) {
+      nsCOMPtr<nsIDOMElement> element;
+      domdoc->GetDocumentElement(getter_AddRefs(element));
+      if (element)
+        node = element;
+    }
+  }
+
+  return node;
+}
+
+// generic "retrieve the value of a XUL attribute" function
+void GetAttribute(nsIXULWindow *inWindow, const nsAString &inAttribute,
+                  nsAString &outValue)
+{
+  nsCOMPtr<nsIDocShell> shell;
+  if (inWindow && NS_SUCCEEDED(inWindow->GetDocShell(getter_AddRefs(shell)))) {
+    nsCOMPtr<nsIDOMNode> node(GetDOMNodeFromDocShell(shell));
+    if (node) {
+      nsCOMPtr<nsIDOMElement> webshellElement(do_QueryInterface(node));
+      if (webshellElement)
+        webshellElement->GetAttribute(inAttribute, outValue);
+    }
+  }
+}
+
+// retrieve the window type, stored as the value of a particular
+// attribute in its XUL window tag
+void GetWindowType(nsIXULWindow* aWindow, nsString &outType)
+{
+  GetAttribute(aWindow, NS_LITERAL_STRING("windowtype"), outType);
+}
+
+//
+// nsWindowInfo
+//
+
+nsWindowInfo::nsWindowInfo(nsIXULWindow* inWindow, int32_t inTimeStamp) :
+  mWindow(inWindow),mTimeStamp(inTimeStamp),mZLevel(nsIXULWindow::normalZ)
+{
+  ReferenceSelf(true, true);
+}
+
+nsWindowInfo::~nsWindowInfo()
+{
+}
+
+// return true if the window described by this WindowInfo has a type
+// equal to the given type
+bool nsWindowInfo::TypeEquals(const nsAString &aType)
+{ 
+  nsAutoString rtnString;
+  GetWindowType(mWindow, rtnString);
+  return rtnString == aType;
+}
+
+// insert the struct into their two linked lists, in position after the
+// given (independent) method arguments
+void nsWindowInfo::InsertAfter(nsWindowInfo *inOlder , nsWindowInfo *inHigher)
+{
+  if (inOlder) {
+    mOlder = inOlder;
+    mYounger = inOlder->mYounger;
+    mOlder->mYounger = this;
+    if (mOlder->mOlder == mOlder)
+      mOlder->mOlder = this;
+    mYounger->mOlder = this;
+    if (mYounger->mYounger == mYounger)
+      mYounger->mYounger = this;
+  }
+  if (inHigher) {
+    mHigher = inHigher;
+    mLower = inHigher->mLower;
+    mHigher->mLower = this;
+    if (mHigher->mHigher == mHigher)
+      mHigher->mHigher = this;
+    mLower->mHigher = this;
+    if (mLower->mLower == mLower)
+      mLower->mLower = this;
+  }
+}
+
+// remove the struct from its linked lists
+void nsWindowInfo::Unlink(bool inAge, bool inZ)
+{
+  if (inAge) {
+    mOlder->mYounger = mYounger;
+    mYounger->mOlder = mOlder;
+  }
+  if (inZ) {
+    mLower->mHigher = mHigher;
+    mHigher->mLower = mLower;
+  }
+  ReferenceSelf(inAge, inZ);
+}
+
+// initialize the struct to be a valid linked list of one element
+void nsWindowInfo::ReferenceSelf(bool inAge, bool inZ)
+{
+  if (inAge) {
+    mYounger = this;
+    mOlder = this;
+  }
+  if (inZ) {
+    mLower = this;
+    mHigher = this;
+  }
+}
+
+//
+// nsAppShellWindowEnumerator
+//
+
+NS_IMPL_ISUPPORTS(nsAppShellWindowEnumerator, nsISimpleEnumerator)
+
+nsAppShellWindowEnumerator::nsAppShellWindowEnumerator(
+    const char16_t* aTypeString,
+    nsWindowMediator& aMediator) :
+      mWindowMediator(&aMediator), mType(aTypeString), mCurrentPosition(nullptr)
+{
+  mWindowMediator->AddEnumerator(this);
+  NS_ADDREF(mWindowMediator);
+}
+
+nsAppShellWindowEnumerator::~nsAppShellWindowEnumerator()
+{
+  mWindowMediator->RemoveEnumerator(this);
+  NS_RELEASE(mWindowMediator);
+}
+
+// after mCurrentPosition has been initialized to point to the beginning
+// of the appropriate list, adjust it if necessary
+void nsAppShellWindowEnumerator::AdjustInitialPosition()
+{
+  if (!mType.IsEmpty() && mCurrentPosition && !mCurrentPosition->TypeEquals(mType))
+    mCurrentPosition = FindNext();
+}
+
+NS_IMETHODIMP nsAppShellWindowEnumerator::HasMoreElements(bool *retval)
+{
+  if (!retval)
+    return NS_ERROR_INVALID_ARG;
+
+  *retval = mCurrentPosition ? true : false;
+  return NS_OK;
+}
+
+// if a window is being removed adjust the iterator's current position
+void nsAppShellWindowEnumerator::WindowRemoved(nsWindowInfo *inInfo)
+{
+  if (mCurrentPosition == inInfo)
+    mCurrentPosition = FindNext();
+}
+
+//
+// nsASDOMWindowEnumerator
+//
+
+nsASDOMWindowEnumerator::nsASDOMWindowEnumerator(
+    const char16_t* aTypeString,
+    nsWindowMediator& aMediator) :
+      nsAppShellWindowEnumerator(aTypeString, aMediator)
+{
+}
+
+nsASDOMWindowEnumerator::~nsASDOMWindowEnumerator()
+{
+}
+
+NS_IMETHODIMP nsASDOMWindowEnumerator::GetNext(nsISupports **retval)
+{
+  if (!retval)
+    return NS_ERROR_INVALID_ARG;
+
+  *retval = nullptr;
+  while (mCurrentPosition) {
+    nsCOMPtr<nsPIDOMWindowOuter> domWindow;
+    nsWindowMediator::GetDOMWindow(mCurrentPosition->mWindow, domWindow);
+    mCurrentPosition = FindNext();
+    if (domWindow)
+      return CallQueryInterface(domWindow, retval);
+  }
+  return NS_OK;
+}
+
+//
+// nsASXULWindowEnumerator
+//
+
+nsASXULWindowEnumerator::nsASXULWindowEnumerator(
+    const char16_t* aTypeString,
+    nsWindowMediator& aMediator) :
+      nsAppShellWindowEnumerator(aTypeString, aMediator)
+{
+}
+
+nsASXULWindowEnumerator::~nsASXULWindowEnumerator()
+{
+}
+
+NS_IMETHODIMP nsASXULWindowEnumerator::GetNext(nsISupports **retval)
+{
+  if (!retval)
+    return NS_ERROR_INVALID_ARG;
+
+  *retval = nullptr;
+  if (mCurrentPosition) {
+    CallQueryInterface(mCurrentPosition->mWindow, retval);
+    mCurrentPosition = FindNext();
+  }
+  return NS_OK;
+}
+
+//
+// nsASDOMWindowEarlyToLateEnumerator
+//
+
+nsASDOMWindowEarlyToLateEnumerator::nsASDOMWindowEarlyToLateEnumerator(
+    const char16_t *aTypeString,
+    nsWindowMediator &aMediator) :
+      nsASDOMWindowEnumerator(aTypeString, aMediator)
+{
+  mCurrentPosition = aMediator.mOldestWindow;
+  AdjustInitialPosition();
+}
+
+nsASDOMWindowEarlyToLateEnumerator::~nsASDOMWindowEarlyToLateEnumerator()
+{
+}
+
+nsWindowInfo *nsASDOMWindowEarlyToLateEnumerator::FindNext()
+{
+  nsWindowInfo *info,
+               *listEnd;
+  bool          allWindows = mType.IsEmpty();
+
+  // see nsXULWindowEarlyToLateEnumerator::FindNext
+  if (!mCurrentPosition)
+    return nullptr;
+
+  info = mCurrentPosition->mYounger;
+  listEnd = mWindowMediator->mOldestWindow;
+
+  while (info != listEnd) {
+    if (allWindows || info->TypeEquals(mType))
+      return info;
+    info = info->mYounger;
+  }
+
+  return nullptr;
+}
+
+//
+// nsASXULWindowEarlyToLateEnumerator
+//
+
+nsASXULWindowEarlyToLateEnumerator::nsASXULWindowEarlyToLateEnumerator(
+    const char16_t *aTypeString,
+    nsWindowMediator &aMediator) :
+      nsASXULWindowEnumerator(aTypeString, aMediator)
+{
+  mCurrentPosition = aMediator.mOldestWindow;
+  AdjustInitialPosition();
+}
+
+nsASXULWindowEarlyToLateEnumerator::~nsASXULWindowEarlyToLateEnumerator()
+{
+}
+
+nsWindowInfo *nsASXULWindowEarlyToLateEnumerator::FindNext()
+{
+  nsWindowInfo *info,
+               *listEnd;
+  bool          allWindows = mType.IsEmpty();
+
+  /* mCurrentPosition null is assumed to mean that the enumerator has run
+     its course and is now basically useless. It could also be interpreted
+     to mean that it was created at a time when there were no windows. In
+     that case it would probably be more appropriate to check to see whether
+     windows have subsequently been added. But it's not guaranteed that we'll
+     pick up newly added windows anyway (if they occurred previous to our
+     current position) so we just don't worry about that. */
+  if (!mCurrentPosition)
+    return nullptr;
+
+  info = mCurrentPosition->mYounger;
+  listEnd = mWindowMediator->mOldestWindow;
+
+  while (info != listEnd) {
+    if (allWindows || info->TypeEquals(mType))
+      return info;
+    info = info->mYounger;
+  }
+
+  return nullptr;
+}
+
+//
+// nsASDOMWindowFrontToBackEnumerator
+//
+
+nsASDOMWindowFrontToBackEnumerator::nsASDOMWindowFrontToBackEnumerator(
+    const char16_t *aTypeString,
+    nsWindowMediator &aMediator) :
+      nsASDOMWindowEnumerator(aTypeString, aMediator)
+{
+  mCurrentPosition = aMediator.mTopmostWindow;
+  AdjustInitialPosition();
+}
+
+nsASDOMWindowFrontToBackEnumerator::~nsASDOMWindowFrontToBackEnumerator()
+{
+}
+
+nsWindowInfo *nsASDOMWindowFrontToBackEnumerator::FindNext()
+{
+  nsWindowInfo *info,
+               *listEnd;
+  bool          allWindows = mType.IsEmpty();
+
+  // see nsXULWindowEarlyToLateEnumerator::FindNext
+  if (!mCurrentPosition)
+    return nullptr;
+
+  info = mCurrentPosition->mLower;
+  listEnd = mWindowMediator->mTopmostWindow;
+
+  while (info != listEnd) {
+    if (allWindows || info->TypeEquals(mType))
+      return info;
+    info = info->mLower;
+  }
+
+  return nullptr;
+}
+
+//
+// nsASXULWindowFrontToBackEnumerator
+//
+
+nsASXULWindowFrontToBackEnumerator::nsASXULWindowFrontToBackEnumerator(
+    const char16_t *aTypeString,
+    nsWindowMediator &aMediator) :
+      nsASXULWindowEnumerator(aTypeString, aMediator)
+{
+  mCurrentPosition = aMediator.mTopmostWindow;
+  AdjustInitialPosition();
+}
+
+nsASXULWindowFrontToBackEnumerator::~nsASXULWindowFrontToBackEnumerator()
+{
+}
+
+nsWindowInfo *nsASXULWindowFrontToBackEnumerator::FindNext()
+{
+  nsWindowInfo *info,
+               *listEnd;
+  bool          allWindows = mType.IsEmpty();
+
+  // see nsXULWindowEarlyToLateEnumerator::FindNext
+  if (!mCurrentPosition)
+    return nullptr;
+
+  info = mCurrentPosition->mLower;
+  listEnd = mWindowMediator->mTopmostWindow;
+
+  while (info != listEnd) {
+    if (allWindows || info->TypeEquals(mType))
+      return info;
+    info = info->mLower;
+  }
+
+  return nullptr;
+}
+
+//
+// nsASDOMWindowBackToFrontEnumerator
+//
+
+nsASDOMWindowBackToFrontEnumerator::nsASDOMWindowBackToFrontEnumerator(
+    const char16_t *aTypeString,
+    nsWindowMediator &aMediator) :
+  nsASDOMWindowEnumerator(aTypeString, aMediator)
+{
+  mCurrentPosition = aMediator.mTopmostWindow ?
+                     aMediator.mTopmostWindow->mHigher : nullptr;
+  AdjustInitialPosition();
+}
+
+nsASDOMWindowBackToFrontEnumerator::~nsASDOMWindowBackToFrontEnumerator()
+{
+}
+
+nsWindowInfo *nsASDOMWindowBackToFrontEnumerator::FindNext()
+{
+  nsWindowInfo *info,
+               *listEnd;
+  bool          allWindows = mType.IsEmpty();
+
+  // see nsXULWindowEarlyToLateEnumerator::FindNext
+  if (!mCurrentPosition)
+    return nullptr;
+
+  info = mCurrentPosition->mHigher;
+  listEnd = mWindowMediator->mTopmostWindow;
+  if (listEnd)
+    listEnd = listEnd->mHigher;
+
+  while (info != listEnd) {
+    if (allWindows || info->TypeEquals(mType))
+      return info;
+    info = info->mHigher;
+  }
+
+  return nullptr;
+}
+
+//
+// nsASXULWindowBackToFrontEnumerator
+//
+
+nsASXULWindowBackToFrontEnumerator::nsASXULWindowBackToFrontEnumerator(
+    const char16_t *aTypeString,
+    nsWindowMediator &aMediator) :
+      nsASXULWindowEnumerator(aTypeString, aMediator)
+{
+  mCurrentPosition = aMediator.mTopmostWindow ?
+                     aMediator.mTopmostWindow->mHigher : nullptr;
+  AdjustInitialPosition();
+}
+
+nsASXULWindowBackToFrontEnumerator::~nsASXULWindowBackToFrontEnumerator()
+{
+}
+
+nsWindowInfo *nsASXULWindowBackToFrontEnumerator::FindNext()
+{
+  nsWindowInfo *info,
+               *listEnd;
+  bool          allWindows = mType.IsEmpty();
+
+  // see nsXULWindowEarlyToLateEnumerator::FindNext
+  if (!mCurrentPosition)
+    return nullptr;
+
+  info = mCurrentPosition->mHigher;
+  listEnd = mWindowMediator->mTopmostWindow;
+  if (listEnd)
+    listEnd = listEnd->mHigher;
+
+  while (info != listEnd) {
+    if (allWindows || info->TypeEquals(mType))
+      return info;
+    info = info->mHigher;
+  }
+
+  return nullptr;
+}