Adding upstream version 124.0.1.upstream/124.0.1

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

1 files changed, 223 insertions, 0 deletions

diff --git a/layout/style/CSSFontFaceRule.cpp b/layout/style/CSSFontFaceRule.cpp
new file mode 100644
index 0000000000..1115c9223f
--- /dev/null
+++ b/layout/style/CSSFontFaceRule.cpp
@@ -0,0 +1,223 @@
+/* -*- 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/dom/CSSFontFaceRule.h"
+
+#include "mozilla/dom/CSSFontFaceRuleBinding.h"
+#include "mozilla/dom/CSSStyleDeclarationBinding.h"
+#include "mozilla/ServoBindings.h"
+#include "nsCSSProps.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+// -------------------------------------------
+// CSSFontFaceRuleDecl and related routines
+//
+
+// QueryInterface implementation for CSSFontFaceRuleDecl
+NS_INTERFACE_MAP_BEGIN(CSSFontFaceRuleDecl)
+  NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+  NS_INTERFACE_MAP_ENTRY(nsICSSDeclaration)
+  NS_INTERFACE_MAP_ENTRY(nsISupports)
+  // We forward the cycle collection interfaces to ContainingRule(), which is
+  // never null (in fact, we're part of that object!)
+  if (aIID.Equals(NS_GET_IID(nsCycleCollectionISupports)) ||
+      aIID.Equals(NS_GET_IID(nsXPCOMCycleCollectionParticipant))) {
+    return ContainingRule()->QueryInterface(aIID, aInstancePtr);
+  } else
+NS_INTERFACE_MAP_END
+
+NS_IMPL_ADDREF_USING_AGGREGATOR(CSSFontFaceRuleDecl, ContainingRule())
+NS_IMPL_RELEASE_USING_AGGREGATOR(CSSFontFaceRuleDecl, ContainingRule())
+
+void CSSFontFaceRuleDecl::SetRawAfterClone(
+    RefPtr<StyleLockedFontFaceRule> aRaw) {
+  mRawRule = std::move(aRaw);
+}
+
+// helper for string GetPropertyValue and RemovePropertyValue
+void CSSFontFaceRuleDecl::GetPropertyValue(nsCSSFontDesc aFontDescID,
+                                           nsACString& aResult) const {
+  MOZ_ASSERT(aResult.IsEmpty());
+  Servo_FontFaceRule_GetDescriptorCssText(mRawRule, aFontDescID, &aResult);
+}
+
+void CSSFontFaceRuleDecl::GetCssText(nsACString& aCssText) {
+  MOZ_ASSERT(aCssText.IsEmpty());
+  Servo_FontFaceRule_GetDeclCssText(mRawRule, &aCssText);
+}
+
+void CSSFontFaceRuleDecl::SetCssText(const nsACString& aCssText,
+                                     nsIPrincipal* aSubjectPrincipal,
+                                     ErrorResult& aRv) {
+  if (ContainingRule()->IsReadOnly()) {
+    return;
+  }
+  // bug 443978
+  aRv.ThrowNotSupportedError(
+      "Can't set cssText on CSSFontFaceRule declarations");
+}
+
+void CSSFontFaceRuleDecl::GetPropertyValue(const nsACString& aPropName,
+                                           nsACString& aResult) {
+  aResult.Truncate();
+  nsCSSFontDesc descID = nsCSSProps::LookupFontDesc(aPropName);
+  if (descID != eCSSFontDesc_UNKNOWN) {
+    GetPropertyValue(descID, aResult);
+  }
+}
+
+void CSSFontFaceRuleDecl::RemoveProperty(const nsACString& aPropName,
+                                         nsACString& aResult,
+                                         ErrorResult& aRv) {
+  nsCSSFontDesc descID = nsCSSProps::LookupFontDesc(aPropName);
+  NS_ASSERTION(descID >= eCSSFontDesc_UNKNOWN && descID < eCSSFontDesc_COUNT,
+               "LookupFontDesc returned value out of range");
+
+  if (ContainingRule()->IsReadOnly()) {
+    return;
+  }
+
+  aResult.Truncate();
+  if (descID != eCSSFontDesc_UNKNOWN) {
+    GetPropertyValue(descID, aResult);
+    Servo_FontFaceRule_ResetDescriptor(mRawRule, descID);
+  }
+}
+
+void CSSFontFaceRuleDecl::GetPropertyPriority(const nsACString& aPropName,
+                                              nsACString& aResult) {
+  // font descriptors do not have priorities at present
+  aResult.Truncate();
+}
+
+void CSSFontFaceRuleDecl::SetProperty(const nsACString& aPropName,
+                                      const nsACString& aValue,
+                                      const nsACString& aPriority,
+                                      nsIPrincipal* aSubjectPrincipal,
+                                      ErrorResult& aRv) {
+  // FIXME(heycam): If we are changing unicode-range, then a FontFace object
+  // representing this rule must have its mUnicodeRange value invalidated.
+
+  if (ContainingRule()->IsReadOnly()) {
+    return;
+  }
+
+  // bug 443978
+  aRv.ThrowNotSupportedError(
+      "Can't set properties on CSSFontFaceRule declarations");
+}
+
+uint32_t CSSFontFaceRuleDecl::Length() {
+  return Servo_FontFaceRule_Length(mRawRule);
+}
+
+void CSSFontFaceRuleDecl::IndexedGetter(uint32_t aIndex, bool& aFound,
+                                        nsACString& aResult) {
+  nsCSSFontDesc id = Servo_FontFaceRule_IndexGetter(mRawRule, aIndex);
+  if (id != eCSSFontDesc_UNKNOWN) {
+    aFound = true;
+    aResult.Assign(nsCSSProps::GetStringValue(id));
+  } else {
+    aFound = false;
+  }
+}
+
+css::Rule* CSSFontFaceRuleDecl::GetParentRule() { return ContainingRule(); }
+
+nsINode* CSSFontFaceRuleDecl::GetAssociatedNode() const {
+  return ContainingRule()->GetAssociatedDocumentOrShadowRoot();
+}
+
+nsISupports* CSSFontFaceRuleDecl::GetParentObject() const {
+  return ContainingRule()->GetParentObject();
+}
+
+JSObject* CSSFontFaceRuleDecl::WrapObject(JSContext* cx,
+                                          JS::Handle<JSObject*> aGivenProto) {
+  // If this changes to use a different type, remove the 'concrete'
+  // annotation from CSSStyleDeclaration.
+  return CSSStyleDeclaration_Binding::Wrap(cx, this, aGivenProto);
+}
+
+// -------------------------------------------
+// CSSFontFaceRule
+//
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(CSSFontFaceRule)
+
+NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(CSSFontFaceRule,
+                                               mozilla::css::Rule)
+  // Keep this in sync with IsCCLeaf.
+
+  // Trace the wrapper for our declaration.  This just expands out
+  // NS_IMPL_CYCLE_COLLECTION_TRACE_PRESERVED_WRAPPER which we can't use
+  // directly because the wrapper is on the declaration, not on us.
+  tmp->mDecl.TraceWrapper(aCallbacks, aClosure);
+NS_IMPL_CYCLE_COLLECTION_TRACE_END
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(CSSFontFaceRule)
+  // Keep this in sync with IsCCLeaf.
+
+  // Unlink the wrapper for our declaration.
+  //
+  // Note that this has to happen before unlinking css::Rule.
+  tmp->UnlinkDeclarationWrapper(tmp->mDecl);
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END_INHERITED(mozilla::css::Rule)
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(CSSFontFaceRule,
+                                                  mozilla::css::Rule)
+  // Keep this in sync with IsCCLeaf.
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+bool CSSFontFaceRule::IsCCLeaf() const {
+  if (!Rule::IsCCLeaf()) {
+    return false;
+  }
+
+  return !mDecl.PreservingWrapper();
+}
+
+NS_IMPL_ISUPPORTS_CYCLE_COLLECTION_INHERITED_0(CSSFontFaceRule,
+                                               mozilla::css::Rule)
+
+#ifdef DEBUG
+void CSSFontFaceRule::List(FILE* out, int32_t aIndent) const {
+  nsAutoCString str;
+  for (int32_t i = 0; i < aIndent; i++) {
+    str.AppendLiteral("  ");
+  }
+  Servo_FontFaceRule_Debug(Raw(), &str);
+  fprintf_stderr(out, "%s\n", str.get());
+}
+#endif
+
+StyleCssRuleType CSSFontFaceRule::Type() const {
+  return StyleCssRuleType::FontFace;
+}
+
+void CSSFontFaceRule::SetRawAfterClone(RefPtr<StyleLockedFontFaceRule> aRaw) {
+  mDecl.SetRawAfterClone(std::move(aRaw));
+}
+
+void CSSFontFaceRule::GetCssText(nsACString& aCssText) const {
+  aCssText.Truncate();
+  Servo_FontFaceRule_GetCssText(Raw(), &aCssText);
+}
+
+nsICSSDeclaration* CSSFontFaceRule::Style() { return &mDecl; }
+
+/* virtual */
+size_t CSSFontFaceRule::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const {
+  return aMallocSizeOf(this);
+}
+
+/* virtual */
+JSObject* CSSFontFaceRule::WrapObject(JSContext* aCx,
+                                      JS::Handle<JSObject*> aGivenProto) {
+  return CSSFontFaceRule_Binding::Wrap(aCx, this, aGivenProto);
+}