Adding upstream version 86.0.1.upstream/86.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 219 insertions, 0 deletions

diff --git a/accessible/ipc/ProxyAccessibleBase.h b/accessible/ipc/ProxyAccessibleBase.h
new file mode 100644
index 0000000000..c3ddd817ba
--- /dev/null
+++ b/accessible/ipc/ProxyAccessibleBase.h
@@ -0,0 +1,219 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=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/. */
+
+#ifndef mozilla_a11y_ProxyAccessibleBase_h
+#define mozilla_a11y_ProxyAccessibleBase_h
+
+#include "mozilla/a11y/Role.h"
+#include "nsIAccessibleText.h"
+#include "nsIAccessibleTypes.h"
+#include "Accessible.h"
+#include "nsString.h"
+#include "nsTArray.h"
+#include "nsRect.h"
+#include "Accessible.h"
+
+namespace mozilla {
+namespace a11y {
+
+class Accessible;
+class Attribute;
+class DocAccessibleParent;
+class ProxyAccessible;
+enum class RelationType;
+
+enum Interfaces {
+  HYPERTEXT = 1,
+  HYPERLINK = 1 << 1,
+  IMAGE = 1 << 2,
+  VALUE = 1 << 3,
+  TABLE = 1 << 4,
+  TABLECELL = 1 << 5,
+  DOCUMENT = 1 << 6,
+  SELECTION = 1 << 7,
+  ACTION = 1 << 8,
+};
+
+template <class Derived>
+class ProxyAccessibleBase {
+ public:
+  ~ProxyAccessibleBase() { MOZ_ASSERT(!mWrapper); }
+
+  void AddChildAt(uint32_t aIdx, Derived* aChild) {
+    mChildren.InsertElementAt(aIdx, aChild);
+  }
+
+  uint32_t ChildrenCount() const { return mChildren.Length(); }
+  Derived* ChildAt(uint32_t aIdx) const { return mChildren[aIdx]; }
+  Derived* FirstChild() const {
+    return mChildren.Length() ? mChildren[0] : nullptr;
+  }
+  Derived* LastChild() const {
+    return mChildren.Length() ? mChildren[mChildren.Length() - 1] : nullptr;
+  }
+  Derived* PrevSibling() const {
+    int32_t idx = IndexInParent();
+    if (idx == -1) {
+      return nullptr;  // No parent.
+    }
+    return idx > 0 ? Parent()->mChildren[idx - 1] : nullptr;
+  }
+  Derived* NextSibling() const {
+    int32_t idx = IndexInParent();
+    if (idx == -1) {
+      return nullptr;  // No parent.
+    }
+    MOZ_ASSERT(idx >= 0);
+    size_t newIdx = idx + 1;
+    return newIdx < Parent()->mChildren.Length() ? Parent()->mChildren[newIdx]
+                                                 : nullptr;
+  }
+
+  // XXX evaluate if this is fast enough.
+  int32_t IndexInParent() const {
+    Derived* parent = Parent();
+    if (!parent) {
+      return -1;
+    }
+    return parent->mChildren.IndexOf(static_cast<const Derived*>(this));
+  }
+  uint32_t EmbeddedChildCount() const;
+  int32_t IndexOfEmbeddedChild(const Derived* aChild);
+  Derived* EmbeddedChildAt(size_t aChildIdx);
+
+  void Shutdown();
+
+  void SetChildDoc(DocAccessibleParent* aChildDoc);
+  void ClearChildDoc(DocAccessibleParent* aChildDoc);
+
+  /**
+   * Remove The given child.
+   */
+  void RemoveChild(Derived* aChild) { mChildren.RemoveElement(aChild); }
+
+  /**
+   * Return the proxy for the parent of the wrapped accessible.
+   */
+  Derived* Parent() const;
+
+  Accessible* OuterDocOfRemoteBrowser() const;
+
+  /**
+   * Get the role of the accessible we're proxying.
+   */
+  role Role() const { return mRole; }
+
+  /**
+   * Return true if this is an embedded object.
+   */
+  bool IsEmbeddedObject() const {
+    role role = Role();
+    return role != roles::TEXT_LEAF && role != roles::WHITESPACE &&
+           role != roles::STATICTEXT;
+  }
+
+  /**
+   * Allow the platform to store a pointers worth of data on us.
+   */
+  uintptr_t GetWrapper() const { return mWrapper; }
+  void SetWrapper(uintptr_t aWrapper) { mWrapper = aWrapper; }
+
+  /*
+   * Return the ID of the accessible being proxied.
+   */
+  uint64_t ID() const { return mID; }
+
+  /**
+   * Return the document containing this proxy, or the proxy itself if it is a
+   * document.
+   */
+  DocAccessibleParent* Document() const { return mDoc; }
+
+  /**
+   * Return true if this proxy is a DocAccessibleParent.
+   */
+  bool IsDoc() const { return mIsDoc; }
+  DocAccessibleParent* AsDoc() const { return IsDoc() ? mDoc : nullptr; }
+
+  // XXX checking mRole alone may not result in same behavior as Accessibles
+  // due to ARIA roles. See bug 1210477.
+  inline bool IsTable() const {
+    return mRole == roles::TABLE || mRole == roles::MATHML_TABLE;
+  }
+  inline bool IsTableRow() const {
+    return (mRole == roles::ROW || mRole == roles::MATHML_TABLE_ROW ||
+            mRole == roles::MATHML_LABELED_ROW);
+  }
+  inline bool IsTableCell() const {
+    return (mRole == roles::CELL || mRole == roles::COLUMNHEADER ||
+            mRole == roles::ROWHEADER || mRole == roles::GRID_CELL ||
+            mRole == roles::MATHML_CELL);
+  }
+
+ protected:
+  ProxyAccessibleBase(uint64_t aID, Derived* aParent, DocAccessibleParent* aDoc,
+                      role aRole, uint32_t aInterfaces)
+      : mParent(aParent->ID()),
+        mDoc(aDoc),
+        mWrapper(0),
+        mID(aID),
+        mRole(aRole),
+        mOuterDoc(false),
+        mIsDoc(false),
+        mHasValue(aInterfaces & Interfaces::VALUE),
+        mIsHyperLink(aInterfaces & Interfaces::HYPERLINK),
+        mIsHyperText(aInterfaces & Interfaces::HYPERTEXT),
+        mIsSelection(aInterfaces & Interfaces::SELECTION) {}
+
+  explicit ProxyAccessibleBase(DocAccessibleParent* aThisAsDoc)
+      : mParent(kNoParent),
+        mDoc(aThisAsDoc),
+        mWrapper(0),
+        mID(0),
+        mRole(roles::DOCUMENT),
+        mOuterDoc(false),
+        mIsDoc(true),
+        mHasValue(false),
+        mIsHyperLink(false),
+        mIsHyperText(false),
+        mIsSelection(false) {}
+
+ protected:
+  void SetParent(Derived* aParent);
+
+ private:
+  uintptr_t mParent;
+  static const uintptr_t kNoParent = UINTPTR_MAX;
+
+  friend Derived;
+
+  nsTArray<Derived*> mChildren;
+  DocAccessibleParent* mDoc;
+  uintptr_t mWrapper;
+  uint64_t mID;
+
+ protected:
+  // XXX DocAccessibleParent gets to change this to change the role of
+  // documents.
+  role mRole : 27;
+
+ private:
+  bool mOuterDoc : 1;
+
+ public:
+  const bool mIsDoc : 1;
+  const bool mHasValue : 1;
+  const bool mIsHyperLink : 1;
+  const bool mIsHyperText : 1;
+  const bool mIsSelection : 1;
+};
+
+extern template class ProxyAccessibleBase<ProxyAccessible>;
+
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif