layout/inspector/inDOMUtils.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "mozilla/ArrayUtils.h"
   7 #include "mozilla/EventStates.h"
   8
   9 #include "inDOMUtils.h"
  10 #include "inLayoutUtils.h"
  11
  12 #include "nsIServiceManager.h"
  13 #include "nsISupportsArray.h"
  14 #include "nsString.h"
  15 #include "nsIDOMElement.h"
  16 #include "nsIDocument.h"
  17 #include "nsIPresShell.h"
  18 #include "nsIDOMDocument.h"
  19 #include "nsIDOMCharacterData.h"
  20 #include "nsRuleNode.h"
  21 #include "nsIStyleRule.h"
  22 #include "mozilla/css/StyleRule.h"
  23 #include "nsICSSStyleRuleDOMWrapper.h"
  24 #include "nsIDOMWindow.h"
  25 #include "nsXBLBinding.h"
  26 #include "nsXBLPrototypeBinding.h"
  27 #include "nsIMutableArray.h"
  28 #include "nsBindingManager.h"
  29 #include "ChildIterator.h"
  30 #include "nsComputedDOMStyle.h"
  31 #include "mozilla/EventStateManager.h"
  32 #include "nsIAtom.h"
  33 #include "nsRange.h"
  34 #include "nsContentList.h"
  35 #include "mozilla/CSSStyleSheet.h"
  36 #include "mozilla/dom/Element.h"
  37 #include "nsRuleWalker.h"
  38 #include "nsRuleProcessorData.h"
  39 #include "nsCSSRuleProcessor.h"
  40 #include "mozilla/dom/InspectorUtilsBinding.h"
  41 #include "mozilla/dom/ToJSValue.h"
  42 #include "nsCSSParser.h"
  43 #include "nsCSSProps.h"
  44 #include "nsCSSValue.h"
  45 #include "nsColor.h"
  46 #include "nsStyleSet.h"
  47 #include "nsStyleUtil.h"
  48
  49 using namespace mozilla;
  50 using namespace mozilla::css;
  51 using namespace mozilla::dom;
  52
  53 ///////////////////////////////////////////////////////////////////////////////
  54
  55 inDOMUtils::inDOMUtils()
  56 {
  57 }
  58
  59 inDOMUtils::~inDOMUtils()
  60 {
  61 }
  62
  63 NS_IMPL_ISUPPORTS(inDOMUtils, inIDOMUtils)
  64
  65 ///////////////////////////////////////////////////////////////////////////////
  66 // inIDOMUtils
  67
  68 NS_IMETHODIMP
  69 inDOMUtils::GetAllStyleSheets(nsIDOMDocument *aDocument, uint32_t *aLength,
  70                               nsISupports ***aSheets)
  71 {
  72   NS_ENSURE_ARG_POINTER(aDocument);
  73
  74   nsCOMArray<nsISupports> sheets;
  75
  76   nsCOMPtr<nsIDocument> document = do_QueryInterface(aDocument);
  77   MOZ_ASSERT(document);
  78
  79   // Get the agent, then user sheets in the style set.
  80   nsIPresShell* presShell = document->GetShell();
  81   if (presShell) {
  82     nsStyleSet* styleSet = presShell->StyleSet();
  83     nsStyleSet::sheetType sheetType = nsStyleSet::eAgentSheet;
  84     for (int32_t i = 0; i < styleSet->SheetCount(sheetType); i++) {
  85       sheets.AppendElement(styleSet->StyleSheetAt(sheetType, i));
  86     }
  87     sheetType = nsStyleSet::eUserSheet;
  88     for (int32_t i = 0; i < styleSet->SheetCount(sheetType); i++) {
  89       sheets.AppendElement(styleSet->StyleSheetAt(sheetType, i));
  90     }
  91   }
  92
  93   // Get the document sheets.
  94   for (int32_t i = 0; i < document->GetNumberOfStyleSheets(); i++) {
  95     sheets.AppendElement(document->GetStyleSheetAt(i));
  96   }
  97
  98   nsISupports** ret = static_cast<nsISupports**>(NS_Alloc(sheets.Count() *
  99                                                  sizeof(nsISupports*)));
 100
 101   for (int32_t i = 0; i < sheets.Count(); i++) {
 102     NS_ADDREF(ret[i] = sheets[i]);
 103   }
 104
 105   *aLength = sheets.Count();
 106   *aSheets = ret;
 107
 108   return NS_OK;
 109 }
 110
 111 NS_IMETHODIMP
 112 inDOMUtils::IsIgnorableWhitespace(nsIDOMCharacterData *aDataNode,
 113                                   bool *aReturn)
 114 {
 115   NS_PRECONDITION(aReturn, "Must have an out parameter");
 116
 117   NS_ENSURE_ARG_POINTER(aDataNode);
 118
 119   *aReturn = false;
 120
 121   nsCOMPtr<nsIContent> content = do_QueryInterface(aDataNode);
 122   NS_ASSERTION(content, "Does not implement nsIContent!");
 123
 124   if (!content->TextIsOnlyWhitespace()) {
 125     return NS_OK;
 126   }
 127
 128   // Okay.  We have only white space.  Let's check the white-space
 129   // property now and make sure that this isn't preformatted text...
 130   nsIFrame* frame = content->GetPrimaryFrame();
 131   if (frame) {
 132     const nsStyleText* text = frame->StyleText();
 133     *aReturn = !text->WhiteSpaceIsSignificant();
 134   }
 135   else {
 136     // empty inter-tag text node without frame, e.g., in between <table>\n<tr>
 137     *aReturn = true;
 138   }
 139
 140   return NS_OK;
 141 }
 142
 143 NS_IMETHODIMP
 144 inDOMUtils::GetParentForNode(nsIDOMNode* aNode,
 145                              bool aShowingAnonymousContent,
 146                              nsIDOMNode** aParent)
 147 {
 148   NS_ENSURE_ARG_POINTER(aNode);
 149
 150   // First do the special cases -- document nodes and anonymous content
 151   nsCOMPtr<nsIDocument> doc(do_QueryInterface(aNode));
 152   nsCOMPtr<nsIDOMNode> parent;
 153
 154   if (doc) {
 155     parent = inLayoutUtils::GetContainerFor(*doc);
 156   } else if (aShowingAnonymousContent) {
 157     nsCOMPtr<nsIContent> content = do_QueryInterface(aNode);
 158     if (content) {
 159       nsIContent* bparent = content->GetXBLInsertionParent();
 160       parent = do_QueryInterface(bparent);
 161     }
 162   }
 163
 164   if (!parent) {
 165     // Ok, just get the normal DOM parent node
 166     aNode->GetParentNode(getter_AddRefs(parent));
 167   }
 168
 169   NS_IF_ADDREF(*aParent = parent);
 170   return NS_OK;
 171 }
 172
 173 NS_IMETHODIMP
 174 inDOMUtils::GetChildrenForNode(nsIDOMNode* aNode,
 175                                bool aShowingAnonymousContent,
 176                                nsIDOMNodeList** aChildren)
 177 {
 178   NS_ENSURE_ARG_POINTER(aNode);
 179   NS_PRECONDITION(aChildren, "Must have an out parameter");
 180
 181   nsCOMPtr<nsIDOMNodeList> kids;
 182
 183   if (aShowingAnonymousContent) {
 184     nsCOMPtr<nsIContent> content = do_QueryInterface(aNode);
 185     if (content) {
 186       kids = content->GetChildren(nsIContent::eAllChildren);
 187     }
 188   }
 189
 190   if (!kids) {
 191     aNode->GetChildNodes(getter_AddRefs(kids));
 192   }
 193
 194   kids.forget(aChildren);
 195   return NS_OK;
 196 }
 197
 198 NS_IMETHODIMP
 199 inDOMUtils::GetCSSStyleRules(nsIDOMElement *aElement,
 200                              const nsAString& aPseudo,
 201                              nsISupportsArray **_retval)
 202 {
 203   NS_ENSURE_ARG_POINTER(aElement);
 204
 205   *_retval = nullptr;
 206
 207   nsCOMPtr<nsIAtom> pseudoElt;
 208   if (!aPseudo.IsEmpty()) {
 209     pseudoElt = do_GetAtom(aPseudo);
 210   }
 211
 212   nsRuleNode* ruleNode = nullptr;
 213   nsCOMPtr<Element> element = do_QueryInterface(aElement);
 214   NS_ENSURE_STATE(element);
 215   nsRefPtr<nsStyleContext> styleContext;
 216   GetRuleNodeForElement(element, pseudoElt, getter_AddRefs(styleContext), &ruleNode);
 217   if (!ruleNode) {
 218     // This can fail for elements that are not in the document or
 219     // if the document they're in doesn't have a presshell.  Bail out.
 220     return NS_OK;
 221   }
 222
 223   nsCOMPtr<nsISupportsArray> rules;
 224   NS_NewISupportsArray(getter_AddRefs(rules));
 225   if (!rules) return NS_ERROR_OUT_OF_MEMORY;
 226
 227   nsRefPtr<mozilla::css::StyleRule> cssRule;
 228   for ( ; !ruleNode->IsRoot(); ruleNode = ruleNode->GetParent()) {
 229     cssRule = do_QueryObject(ruleNode->GetRule());
 230     if (cssRule) {
 231       nsCOMPtr<nsIDOMCSSRule> domRule = cssRule->GetDOMRule();
 232       if (domRule)
 233         rules->InsertElementAt(domRule, 0);
 234     }
 235   }
 236
 237   *_retval = rules;
 238   NS_ADDREF(*_retval);
 239
 240   return NS_OK;
 241 }
 242
 243 static already_AddRefed<StyleRule>
 244 GetRuleFromDOMRule(nsIDOMCSSStyleRule *aRule, ErrorResult& rv)
 245 {
 246   nsCOMPtr<nsICSSStyleRuleDOMWrapper> rule = do_QueryInterface(aRule);
 247   if (!rule) {
 248     rv.Throw(NS_ERROR_INVALID_POINTER);
 249     return nullptr;
 250   }
 251
 252   nsRefPtr<StyleRule> cssrule;
 253   rv = rule->GetCSSStyleRule(getter_AddRefs(cssrule));
 254   if (rv.Failed()) {
 255     return nullptr;
 256   }
 257
 258   if (!cssrule) {
 259     rv.Throw(NS_ERROR_FAILURE);
 260   }
 261   return cssrule.forget();
 262 }
 263
 264 NS_IMETHODIMP
 265 inDOMUtils::GetRuleLine(nsIDOMCSSRule* aRule, uint32_t* _retval)
 266 {
 267   NS_ENSURE_ARG_POINTER(aRule);
 268
 269   Rule* rule = aRule->GetCSSRule();
 270   if (!rule) {
 271     return NS_ERROR_FAILURE;
 272   }
 273
 274   *_retval = rule->GetLineNumber();
 275   return NS_OK;
 276 }
 277
 278 NS_IMETHODIMP
 279 inDOMUtils::GetRuleColumn(nsIDOMCSSRule* aRule, uint32_t* _retval)
 280 {
 281   NS_ENSURE_ARG_POINTER(aRule);
 282
 283   Rule* rule = aRule->GetCSSRule();
 284   if (!rule) {
 285     return NS_ERROR_FAILURE;
 286   }
 287
 288   *_retval = rule->GetColumnNumber();
 289   return NS_OK;
 290 }
 291
 292 NS_IMETHODIMP
 293 inDOMUtils::GetSelectorCount(nsIDOMCSSStyleRule* aRule, uint32_t *aCount)
 294 {
 295   ErrorResult rv;
 296   nsRefPtr<StyleRule> rule = GetRuleFromDOMRule(aRule, rv);
 297   if (rv.Failed()) {
 298     return rv.ErrorCode();
 299   }
 300
 301   uint32_t count = 0;
 302   for (nsCSSSelectorList* sel = rule->Selector(); sel; sel = sel->mNext) {
 303     ++count;
 304   }
 305   *aCount = count;
 306   return NS_OK;
 307 }
 308
 309 static nsCSSSelectorList*
 310 GetSelectorAtIndex(nsIDOMCSSStyleRule* aRule, uint32_t aIndex, ErrorResult& rv)
 311 {
 312   nsRefPtr<StyleRule> rule = GetRuleFromDOMRule(aRule, rv);
 313   if (rv.Failed()) {
 314     return nullptr;
 315   }
 316
 317   for (nsCSSSelectorList* sel = rule->Selector(); sel;
 318        sel = sel->mNext, --aIndex) {
 319     if (aIndex == 0) {
 320       return sel;
 321     }
 322   }
 323
 324   // Ran out of selectors
 325   rv.Throw(NS_ERROR_INVALID_ARG);
 326   return nullptr;
 327 }
 328
 329 NS_IMETHODIMP
 330 inDOMUtils::GetSelectorText(nsIDOMCSSStyleRule* aRule,
 331                             uint32_t aSelectorIndex,
 332                             nsAString& aText)
 333 {
 334   ErrorResult rv;
 335   nsCSSSelectorList* sel = GetSelectorAtIndex(aRule, aSelectorIndex, rv);
 336   if (rv.Failed()) {
 337     return rv.ErrorCode();
 338   }
 339
 340   nsRefPtr<StyleRule> rule = GetRuleFromDOMRule(aRule, rv);
 341   MOZ_ASSERT(!rv.Failed(), "How could we get a selector but not a rule?");
 342
 343   sel->mSelectors->ToString(aText, rule->GetStyleSheet(), false);
 344   return NS_OK;
 345 }
 346
 347 NS_IMETHODIMP
 348 inDOMUtils::GetSpecificity(nsIDOMCSSStyleRule* aRule,
 349                             uint32_t aSelectorIndex,
 350                             uint64_t* aSpecificity)
 351 {
 352   ErrorResult rv;
 353   nsCSSSelectorList* sel = GetSelectorAtIndex(aRule, aSelectorIndex, rv);
 354   if (rv.Failed()) {
 355     return rv.ErrorCode();
 356   }
 357
 358   *aSpecificity = sel->mWeight;
 359   return NS_OK;
 360 }
 361
 362 NS_IMETHODIMP
 363 inDOMUtils::SelectorMatchesElement(nsIDOMElement* aElement,
 364                                    nsIDOMCSSStyleRule* aRule,
 365                                    uint32_t aSelectorIndex,
 366                                    const nsAString& aPseudo,
 367                                    bool* aMatches)
 368 {
 369   nsCOMPtr<Element> element = do_QueryInterface(aElement);
 370   NS_ENSURE_ARG_POINTER(element);
 371
 372   ErrorResult rv;
 373   nsCSSSelectorList* tail = GetSelectorAtIndex(aRule, aSelectorIndex, rv);
 374   if (rv.Failed()) {
 375     return rv.ErrorCode();
 376   }
 377
 378   // We want just the one list item, not the whole list tail
 379   nsAutoPtr<nsCSSSelectorList> sel(tail->Clone(false));
 380
 381   // Do not attempt to match if a pseudo element is requested and this is not
 382   // a pseudo element selector, or vice versa.
 383   if (aPseudo.IsEmpty() == sel->mSelectors->IsPseudoElement()) {
 384     *aMatches = false;
 385     return NS_OK;
 386   }
 387
 388   if (!aPseudo.IsEmpty()) {
 389     // We need to make sure that the requested pseudo element type
 390     // matches the selector pseudo element type before proceeding.
 391     nsCOMPtr<nsIAtom> pseudoElt = do_GetAtom(aPseudo);
 392     if (sel->mSelectors->PseudoType() !=
 393         nsCSSPseudoElements::GetPseudoType(pseudoElt)) {
 394       *aMatches = false;
 395       return NS_OK;
 396     }
 397
 398     // We have a matching pseudo element, now remove it so we can compare
 399     // directly against |element| when proceeding into SelectorListMatches.
 400     // It's OK to do this - we just cloned sel and nothing else is using it.
 401     sel->RemoveRightmostSelector();
 402   }
 403
 404   element->OwnerDoc()->FlushPendingLinkUpdates();
 405   // XXXbz what exactly should we do with visited state here?
 406   TreeMatchContext matchingContext(false,
 407                                    nsRuleWalker::eRelevantLinkUnvisited,
 408                                    element->OwnerDoc(),
 409                                    TreeMatchContext::eNeverMatchVisited);
 410   *aMatches = nsCSSRuleProcessor::SelectorListMatches(element, matchingContext,
 411                                                       sel);
 412   return NS_OK;
 413 }
 414
 415 NS_IMETHODIMP
 416 inDOMUtils::IsInheritedProperty(const nsAString &aPropertyName, bool *_retval)
 417 {
 418   nsCSSProperty prop =
 419     nsCSSProps::LookupProperty(aPropertyName, nsCSSProps::eIgnoreEnabledState);
 420   if (prop == eCSSProperty_UNKNOWN) {
 421     *_retval = false;
 422     return NS_OK;
 423   }
 424
 425   if (prop == eCSSPropertyExtra_variable) {
 426     *_retval = true;
 427     return NS_OK;
 428   }
 429
 430   if (nsCSSProps::IsShorthand(prop)) {
 431     prop = nsCSSProps::SubpropertyEntryFor(prop)[0];
 432   }
 433
 434   nsStyleStructID sid = nsCSSProps::kSIDTable[prop];
 435   *_retval = !nsCachedStyleData::IsReset(sid);
 436   return NS_OK;
 437 }
 438
 439 extern const char* const kCSSRawProperties[];
 440
 441 NS_IMETHODIMP
 442 inDOMUtils::GetCSSPropertyNames(uint32_t aFlags, uint32_t* aCount,
 443                                 char16_t*** aProps)
 444 {
 445   // maxCount is the largest number of properties we could have; our actual
 446   // number might be smaller because properties might be disabled.
 447   uint32_t maxCount;
 448   if (aFlags & EXCLUDE_SHORTHANDS) {
 449     maxCount = eCSSProperty_COUNT_no_shorthands;
 450   } else {
 451     maxCount = eCSSProperty_COUNT;
 452   }
 453
 454   if (aFlags & INCLUDE_ALIASES) {
 455     maxCount += (eCSSProperty_COUNT_with_aliases - eCSSProperty_COUNT);
 456   }
 457
 458   char16_t** props =
 459     static_cast<char16_t**>(nsMemory::Alloc(maxCount * sizeof(char16_t*)));
 460
 461 #define DO_PROP(_prop)                                                  \
 462   PR_BEGIN_MACRO                                                        \
 463     nsCSSProperty cssProp = nsCSSProperty(_prop);                       \
 464     if (nsCSSProps::IsEnabled(cssProp)) {                               \
 465       props[propCount] =                                                \
 466         ToNewUnicode(nsDependentCString(kCSSRawProperties[_prop]));     \
 467       ++propCount;                                                      \
 468     }                                                                   \
 469   PR_END_MACRO
 470
 471   // prop is the property id we're considering; propCount is how many properties
 472   // we've put into props so far.
 473   uint32_t prop = 0, propCount = 0;
 474   for ( ; prop < eCSSProperty_COUNT_no_shorthands; ++prop) {
 475     if (nsCSSProps::PropertyParseType(nsCSSProperty(prop)) !=
 476         CSS_PROPERTY_PARSE_INACCESSIBLE) {
 477       DO_PROP(prop);
 478     }
 479   }
 480
 481   if (!(aFlags & EXCLUDE_SHORTHANDS)) {
 482     for ( ; prop < eCSSProperty_COUNT; ++prop) {
 483       // Some shorthands are also aliases
 484       if ((aFlags & INCLUDE_ALIASES) ||
 485           !nsCSSProps::PropHasFlags(nsCSSProperty(prop),
 486                                     CSS_PROPERTY_IS_ALIAS)) {
 487         DO_PROP(prop);
 488       }
 489     }
 490   }
 491
 492   if (aFlags & INCLUDE_ALIASES) {
 493     for (prop = eCSSProperty_COUNT; prop < eCSSProperty_COUNT_with_aliases; ++prop) {
 494       DO_PROP(prop);
 495     }
 496   }
 497
 498 #undef DO_PROP
 499
 500   *aCount = propCount;
 501   *aProps = props;
 502
 503   return NS_OK;
 504 }
 505
 506 static void InsertNoDuplicates(nsTArray<nsString>& aArray,
 507                                const nsAString& aString)
 508 {
 509   size_t i = aArray.IndexOfFirstElementGt(aString);
 510   if (i > 0 && aArray[i-1].Equals(aString)) {
 511     return;
 512   }
 513   aArray.InsertElementAt(i, aString);
 514 }
 515
 516 static void GetKeywordsForProperty(const nsCSSProperty aProperty,
 517                                    nsTArray<nsString>& aArray)
 518 {
 519   if (nsCSSProps::IsShorthand(aProperty)) {
 520     // Shorthand props have no keywords.
 521     return;
 522   }
 523   const nsCSSProps::KTableValue *keywordTable =
 524     nsCSSProps::kKeywordTableTable[aProperty];
 525   if (keywordTable && keywordTable != nsCSSProps::kBoxPropSourceKTable) {
 526     size_t i = 0;
 527     while (nsCSSKeyword(keywordTable[i]) != eCSSKeyword_UNKNOWN) {
 528       nsCSSKeyword word = nsCSSKeyword(keywordTable[i]);
 529       InsertNoDuplicates(aArray,
 530                          NS_ConvertASCIItoUTF16(nsCSSKeywords::GetStringValue(word)));
 531       // Increment counter by 2, because in this table every second
 532       // element is a nsCSSKeyword.
 533       i += 2;
 534     }
 535   }
 536 }
 537
 538 static void GetColorsForProperty(const uint32_t aParserVariant,
 539                                  nsTArray<nsString>& aArray)
 540 {
 541   if (aParserVariant & VARIANT_COLOR) {
 542     // GetKeywordsForProperty and GetOtherValuesForProperty assume aArray is sorted,
 543     // and if aArray is not empty here, then it's not going to be sorted coming out.
 544     MOZ_ASSERT(aArray.Length() == 0);
 545     size_t size;
 546     const char * const *allColorNames = NS_AllColorNames(&size);
 547     for (size_t i = 0; i < size; i++) {
 548       CopyASCIItoUTF16(allColorNames[i], *aArray.AppendElement());
 549     }
 550   }
 551   return;
 552 }
 553
 554 static void GetOtherValuesForProperty(const uint32_t aParserVariant,
 555                                       nsTArray<nsString>& aArray)
 556 {
 557   if (aParserVariant & VARIANT_AUTO) {
 558     InsertNoDuplicates(aArray, NS_LITERAL_STRING("auto"));
 559   }
 560   if (aParserVariant & VARIANT_NORMAL) {
 561     InsertNoDuplicates(aArray, NS_LITERAL_STRING("normal"));
 562   }
 563   if(aParserVariant & VARIANT_ALL) {
 564     InsertNoDuplicates(aArray, NS_LITERAL_STRING("all"));
 565   }
 566   if (aParserVariant & VARIANT_NONE) {
 567     InsertNoDuplicates(aArray, NS_LITERAL_STRING("none"));
 568   }
 569   if (aParserVariant & VARIANT_ELEMENT) {
 570     InsertNoDuplicates(aArray, NS_LITERAL_STRING("-moz-element"));
 571   }
 572   if (aParserVariant & VARIANT_IMAGE_RECT) {
 573     InsertNoDuplicates(aArray, NS_LITERAL_STRING("-moz-image-rect"));
 574   }
 575   if (aParserVariant & VARIANT_COLOR) {
 576     InsertNoDuplicates(aArray, NS_LITERAL_STRING("rgb"));
 577     InsertNoDuplicates(aArray, NS_LITERAL_STRING("hsl"));
 578     InsertNoDuplicates(aArray, NS_LITERAL_STRING("rgba"));
 579     InsertNoDuplicates(aArray, NS_LITERAL_STRING("hsla"));
 580   }
 581   if (aParserVariant & VARIANT_TIMING_FUNCTION) {
 582     InsertNoDuplicates(aArray, NS_LITERAL_STRING("cubic-bezier"));
 583     InsertNoDuplicates(aArray, NS_LITERAL_STRING("steps"));
 584   }
 585   if (aParserVariant & VARIANT_CALC) {
 586     InsertNoDuplicates(aArray, NS_LITERAL_STRING("calc"));
 587     InsertNoDuplicates(aArray, NS_LITERAL_STRING("-moz-calc"));
 588   }
 589   if (aParserVariant & VARIANT_URL) {
 590     InsertNoDuplicates(aArray, NS_LITERAL_STRING("url"));
 591   }
 592   if (aParserVariant & VARIANT_GRADIENT) {
 593     InsertNoDuplicates(aArray, NS_LITERAL_STRING("linear-gradient"));
 594     InsertNoDuplicates(aArray, NS_LITERAL_STRING("radial-gradient"));
 595     InsertNoDuplicates(aArray, NS_LITERAL_STRING("repeating-linear-gradient"));
 596     InsertNoDuplicates(aArray, NS_LITERAL_STRING("repeating-radial-gradient"));
 597     InsertNoDuplicates(aArray, NS_LITERAL_STRING("-moz-linear-gradient"));
 598     InsertNoDuplicates(aArray, NS_LITERAL_STRING("-moz-radial-gradient"));
 599     InsertNoDuplicates(aArray, NS_LITERAL_STRING("-moz-repeating-linear-gradient"));
 600     InsertNoDuplicates(aArray, NS_LITERAL_STRING("-moz-repeating-radial-gradient"));
 601   }
 602 }
 603
 604 NS_IMETHODIMP
 605 inDOMUtils::GetSubpropertiesForCSSProperty(const nsAString& aProperty,
 606                                            uint32_t* aLength,
 607                                            char16_t*** aValues)
 608 {
 609   nsCSSProperty propertyID =
 610     nsCSSProps::LookupProperty(aProperty, nsCSSProps::eEnabledForAllContent);
 611
 612   if (propertyID == eCSSProperty_UNKNOWN ||
 613       propertyID == eCSSPropertyExtra_variable) {
 614     return NS_ERROR_FAILURE;
 615   }
 616
 617   nsTArray<nsString> array;
 618   if (!nsCSSProps::IsShorthand(propertyID)) {
 619     *aValues = static_cast<char16_t**>(nsMemory::Alloc(sizeof(char16_t*)));
 620     (*aValues)[0] = ToNewUnicode(nsCSSProps::GetStringValue(propertyID));
 621     *aLength = 1;
 622     return NS_OK;
 623   }
 624
 625   // Count up how many subproperties we have.
 626   size_t subpropCount = 0;
 627   for (const nsCSSProperty *props = nsCSSProps::SubpropertyEntryFor(propertyID);
 628        *props != eCSSProperty_UNKNOWN; ++props) {
 629     ++subpropCount;
 630   }
 631
 632   *aValues =
 633     static_cast<char16_t**>(nsMemory::Alloc(subpropCount * sizeof(char16_t*)));
 634   *aLength = subpropCount;
 635   for (const nsCSSProperty *props = nsCSSProps::SubpropertyEntryFor(propertyID),
 636                            *props_start = props;
 637        *props != eCSSProperty_UNKNOWN; ++props) {
 638     (*aValues)[props-props_start] = ToNewUnicode(nsCSSProps::GetStringValue(*props));
 639   }
 640   return NS_OK;
 641 }
 642
 643 NS_IMETHODIMP
 644 inDOMUtils::CssPropertyIsShorthand(const nsAString& aProperty, bool *_retval)
 645 {
 646   nsCSSProperty propertyID =
 647     nsCSSProps::LookupProperty(aProperty, nsCSSProps::eEnabledForAllContent);
 648   if (propertyID == eCSSProperty_UNKNOWN) {
 649     return NS_ERROR_FAILURE;
 650   }
 651
 652   *_retval = nsCSSProps::IsShorthand(propertyID);
 653   return NS_OK;
 654 }
 655
 656 NS_IMETHODIMP
 657 inDOMUtils::CssPropertySupportsType(const nsAString& aProperty, uint32_t aType,
 658                                     bool *_retval)
 659 {
 660   nsCSSProperty propertyID =
 661     nsCSSProps::LookupProperty(aProperty, nsCSSProps::eEnabledForAllContent);
 662   if (propertyID == eCSSProperty_UNKNOWN) {
 663     return NS_ERROR_FAILURE;
 664   }
 665
 666   uint32_t variant;
 667   switch (aType) {
 668   case TYPE_LENGTH:
 669     variant = VARIANT_LENGTH;
 670     break;
 671   case TYPE_PERCENTAGE:
 672     variant = VARIANT_PERCENT;
 673     break;
 674   case TYPE_COLOR:
 675     variant = VARIANT_COLOR;
 676     break;
 677   case TYPE_URL:
 678     variant = VARIANT_URL;
 679     break;
 680   case TYPE_ANGLE:
 681     variant = VARIANT_ANGLE;
 682     break;
 683   case TYPE_FREQUENCY:
 684     variant = VARIANT_FREQUENCY;
 685     break;
 686   case TYPE_TIME:
 687     variant = VARIANT_TIME;
 688     break;
 689   case TYPE_GRADIENT:
 690     variant = VARIANT_GRADIENT;
 691     break;
 692   case TYPE_TIMING_FUNCTION:
 693     variant = VARIANT_TIMING_FUNCTION;
 694     break;
 695   case TYPE_IMAGE_RECT:
 696     variant = VARIANT_IMAGE_RECT;
 697     break;
 698   case TYPE_NUMBER:
 699     // Include integers under "number"?
 700     variant = VARIANT_NUMBER | VARIANT_INTEGER;
 701     break;
 702   default:
 703     // Unknown type
 704     return NS_ERROR_NOT_AVAILABLE;
 705   }
 706
 707   if (!nsCSSProps::IsShorthand(propertyID)) {
 708     *_retval = nsCSSProps::ParserVariant(propertyID) & variant;
 709     return NS_OK;
 710   }
 711
 712   for (const nsCSSProperty* props = nsCSSProps::SubpropertyEntryFor(propertyID);
 713        *props != eCSSProperty_UNKNOWN; ++props) {
 714     if (nsCSSProps::ParserVariant(*props) & variant) {
 715       *_retval = true;
 716       return NS_OK;
 717     }
 718   }
 719
 720   *_retval = false;
 721   return NS_OK;
 722 }
 723
 724 NS_IMETHODIMP
 725 inDOMUtils::GetCSSValuesForProperty(const nsAString& aProperty,
 726                                     uint32_t* aLength,
 727                                     char16_t*** aValues)
 728 {
 729   nsCSSProperty propertyID = nsCSSProps::LookupProperty(aProperty,
 730                                                         nsCSSProps::eEnabledForAllContent);
 731   if (propertyID == eCSSProperty_UNKNOWN) {
 732     return NS_ERROR_FAILURE;
 733   }
 734
 735   nsTArray<nsString> array;
 736   // We start collecting the values, BUT colors need to go in first, because array
 737   // needs to stay sorted, and the colors are sorted, so we just append them.
 738   if (propertyID == eCSSPropertyExtra_variable) {
 739     // No other values we can report.
 740   } else if (!nsCSSProps::IsShorthand(propertyID)) {
 741     // Property is longhand.
 742     uint32_t propertyParserVariant = nsCSSProps::ParserVariant(propertyID);
 743     // Get colors first.
 744     GetColorsForProperty(propertyParserVariant, array);
 745     if (propertyParserVariant & VARIANT_KEYWORD) {
 746       GetKeywordsForProperty(propertyID, array);
 747     }
 748     GetOtherValuesForProperty(propertyParserVariant, array);
 749   } else {
 750     // Property is shorthand.
 751     CSSPROPS_FOR_SHORTHAND_SUBPROPERTIES(subproperty, propertyID) {
 752       // Get colors (once) first.
 753       uint32_t propertyParserVariant = nsCSSProps::ParserVariant(*subproperty);
 754       if (propertyParserVariant & VARIANT_COLOR) {
 755         GetColorsForProperty(propertyParserVariant, array);
 756         break;
 757       }
 758     }
 759     CSSPROPS_FOR_SHORTHAND_SUBPROPERTIES(subproperty, propertyID) {
 760       uint32_t propertyParserVariant = nsCSSProps::ParserVariant(*subproperty);
 761       if (propertyParserVariant & VARIANT_KEYWORD) {
 762         GetKeywordsForProperty(*subproperty, array);
 763       }
 764       GetOtherValuesForProperty(propertyParserVariant, array);
 765     }
 766   }
 767   // All CSS properties take initial, inherit and unset.
 768   InsertNoDuplicates(array, NS_LITERAL_STRING("initial"));
 769   InsertNoDuplicates(array, NS_LITERAL_STRING("inherit"));
 770   InsertNoDuplicates(array, NS_LITERAL_STRING("unset"));
 771
 772   *aLength = array.Length();
 773   char16_t** ret =
 774     static_cast<char16_t**>(NS_Alloc(*aLength * sizeof(char16_t*)));
 775   for (uint32_t i = 0; i < *aLength; ++i) {
 776     ret[i] = ToNewUnicode(array[i]);
 777   }
 778   *aValues = ret;
 779   return NS_OK;
 780 }
 781
 782 NS_IMETHODIMP
 783 inDOMUtils::ColorNameToRGB(const nsAString& aColorName, JSContext* aCx,
 784                            JS::MutableHandle<JS::Value> aValue)
 785 {
 786   nscolor color;
 787   if (!NS_ColorNameToRGB(aColorName, &color)) {
 788     return NS_ERROR_INVALID_ARG;
 789   }
 790
 791   InspectorRGBTriple triple;
 792   triple.mR = NS_GET_R(color);
 793   triple.mG = NS_GET_G(color);
 794   triple.mB = NS_GET_B(color);
 795
 796   if (!ToJSValue(aCx, triple, aValue)) {
 797     return NS_ERROR_FAILURE;
 798   }
 799
 800   return NS_OK;
 801 }
 802
 803 NS_IMETHODIMP
 804 inDOMUtils::RgbToColorName(uint8_t aR, uint8_t aG, uint8_t aB,
 805                            nsAString& aColorName)
 806 {
 807   const char* color = NS_RGBToColorName(NS_RGB(aR, aG, aB));
 808   if (!color) {
 809     aColorName.Truncate();
 810     return NS_ERROR_INVALID_ARG;
 811   }
 812
 813   aColorName.AssignASCII(color);
 814   return NS_OK;
 815 }
 816
 817 NS_IMETHODIMP
 818 inDOMUtils::ColorToRGBA(const nsAString& aColorString, JSContext* aCx,
 819                         JS::MutableHandle<JS::Value> aValue)
 820 {
 821   nscolor color = 0;
 822   nsCSSParser cssParser;
 823   nsCSSValue cssValue;
 824
 825   bool isColor = cssParser.ParseColorString(aColorString, nullptr, 0,
 826                                             cssValue, true);
 827
 828   if (!isColor) {
 829     aValue.setNull();
 830     return NS_OK;
 831   }
 832
 833   nsRuleNode::ComputeColor(cssValue, nullptr, nullptr, color);
 834
 835   InspectorRGBATuple tuple;
 836   tuple.mR = NS_GET_R(color);
 837   tuple.mG = NS_GET_G(color);
 838   tuple.mB = NS_GET_B(color);
 839   tuple.mA = nsStyleUtil::ColorComponentToFloat(NS_GET_A(color));
 840
 841   if (!ToJSValue(aCx, tuple, aValue)) {
 842     return NS_ERROR_FAILURE;
 843   }
 844
 845   return NS_OK;
 846 }
 847
 848 NS_IMETHODIMP
 849 inDOMUtils::IsValidCSSColor(const nsAString& aColorString, bool *_retval)
 850 {
 851   nsCSSParser cssParser;
 852   nsCSSValue cssValue;
 853   *_retval = cssParser.ParseColorString(aColorString, nullptr, 0, cssValue, true);
 854   return NS_OK;
 855 }
 856
 857 NS_IMETHODIMP
 858 inDOMUtils::CssPropertyIsValid(const nsAString& aPropertyName,
 859                                const nsAString& aPropertyValue,
 860                                bool *_retval)
 861 {
 862   nsCSSProperty propertyID =
 863     nsCSSProps::LookupProperty(aPropertyName, nsCSSProps::eIgnoreEnabledState);
 864
 865   if (propertyID == eCSSProperty_UNKNOWN) {
 866     *_retval = false;
 867     return NS_OK;
 868   }
 869
 870   // Get a parser, parse the property.
 871   nsCSSParser parser;
 872   *_retval = parser.IsValueValidForProperty(propertyID, aPropertyValue);
 873
 874   return NS_OK;
 875 }
 876
 877 NS_IMETHODIMP
 878 inDOMUtils::GetBindingURLs(nsIDOMElement *aElement, nsIArray **_retval)
 879 {
 880   NS_ENSURE_ARG_POINTER(aElement);
 881
 882   *_retval = nullptr;
 883
 884   nsCOMPtr<nsIMutableArray> urls = do_CreateInstance(NS_ARRAY_CONTRACTID);
 885   if (!urls)
 886     return NS_ERROR_FAILURE;
 887
 888   nsCOMPtr<nsIContent> content = do_QueryInterface(aElement);
 889   NS_ENSURE_ARG_POINTER(content);
 890
 891   nsXBLBinding *binding = content->GetXBLBinding();
 892
 893   while (binding) {
 894     urls->AppendElement(binding->PrototypeBinding()->BindingURI(), false);
 895     binding = binding->GetBaseBinding();
 896   }
 897
 898   NS_ADDREF(*_retval = urls);
 899   return NS_OK;
 900 }
 901
 902 NS_IMETHODIMP
 903 inDOMUtils::SetContentState(nsIDOMElement* aElement,
 904                             EventStates::InternalType aState)
 905 {
 906   NS_ENSURE_ARG_POINTER(aElement);
 907
 908   nsRefPtr<EventStateManager> esm =
 909     inLayoutUtils::GetEventStateManagerFor(aElement);
 910   if (esm) {
 911     nsCOMPtr<nsIContent> content;
 912     content = do_QueryInterface(aElement);
 913
 914     // XXX Invalid cast of bool to nsresult (bug 778108)
 915     return (nsresult)esm->SetContentState(content, EventStates(aState));
 916   }
 917
 918   return NS_ERROR_FAILURE;
 919 }
 920
 921 NS_IMETHODIMP
 922 inDOMUtils::GetContentState(nsIDOMElement* aElement,
 923                             EventStates::InternalType* aState)
 924 {
 925   *aState = 0;
 926   nsCOMPtr<nsIContent> content = do_QueryInterface(aElement);
 927   NS_ENSURE_ARG_POINTER(content);
 928
 929   // NOTE: if this method is removed,
 930   // please remove GetInternalValue from EventStates
 931   *aState = content->AsElement()->State().GetInternalValue();
 932   return NS_OK;
 933 }
 934
 935 /* static */ nsresult
 936 inDOMUtils::GetRuleNodeForElement(dom::Element* aElement,
 937                                   nsIAtom* aPseudo,
 938                                   nsStyleContext** aStyleContext,
 939                                   nsRuleNode** aRuleNode)
 940 {
 941   MOZ_ASSERT(aElement);
 942
 943   *aRuleNode = nullptr;
 944   *aStyleContext = nullptr;
 945
 946   nsIDocument* doc = aElement->GetComposedDoc();
 947   NS_ENSURE_TRUE(doc, NS_ERROR_UNEXPECTED);
 948
 949   nsIPresShell *presShell = doc->GetShell();
 950   NS_ENSURE_TRUE(presShell, NS_ERROR_UNEXPECTED);
 951
 952   nsPresContext *presContext = presShell->GetPresContext();
 953   NS_ENSURE_TRUE(presContext, NS_ERROR_UNEXPECTED);
 954
 955   presContext->EnsureSafeToHandOutCSSRules();
 956
 957   nsRefPtr<nsStyleContext> sContext =
 958     nsComputedDOMStyle::GetStyleContextForElement(aElement, aPseudo, presShell);
 959   if (sContext) {
 960     *aRuleNode = sContext->RuleNode();
 961     sContext.forget(aStyleContext);
 962   }
 963   return NS_OK;
 964 }
 965
 966 NS_IMETHODIMP
 967 inDOMUtils::GetUsedFontFaces(nsIDOMRange* aRange,
 968                              nsIDOMFontFaceList** aFontFaceList)
 969 {
 970   return static_cast<nsRange*>(aRange)->GetUsedFontFaces(aFontFaceList);
 971 }
 972
 973 static EventStates
 974 GetStatesForPseudoClass(const nsAString& aStatePseudo)
 975 {
 976   // An array of the states that are relevant for various pseudoclasses.
 977   // XXXbz this duplicates code in nsCSSRuleProcessor
 978   static const EventStates sPseudoClassStates[] = {
 979 #define CSS_PSEUDO_CLASS(_name, _value, _pref)  \
 980     EventStates(),
 981 #define CSS_STATE_PSEUDO_CLASS(_name, _value, _pref, _states)   \
 982     _states,
 983 #include "nsCSSPseudoClassList.h"
 984 #undef CSS_STATE_PSEUDO_CLASS
 985 #undef CSS_PSEUDO_CLASS
 986
 987     // Add more entries for our fake values to make sure we can't
 988     // index out of bounds into this array no matter what.
 989     EventStates(),
 990     EventStates()
 991   };
 992   static_assert(MOZ_ARRAY_LENGTH(sPseudoClassStates) ==
 993                 nsCSSPseudoClasses::ePseudoClass_NotPseudoClass + 1,
 994                 "Length of PseudoClassStates array is incorrect");
 995
 996   nsCOMPtr<nsIAtom> atom = do_GetAtom(aStatePseudo);
 997
 998   // Ignore :moz-any-link so we don't give the element simultaneous
 999   // visited and unvisited style state
1000   if (nsCSSPseudoClasses::GetPseudoType(atom) ==
1001       nsCSSPseudoClasses::ePseudoClass_mozAnyLink) {
1002     return EventStates();
1003   }
1004   // Our array above is long enough that indexing into it with
1005   // NotPseudoClass is ok.
1006   return sPseudoClassStates[nsCSSPseudoClasses::GetPseudoType(atom)];
1007 }
1008
1009 NS_IMETHODIMP
1010 inDOMUtils::AddPseudoClassLock(nsIDOMElement *aElement,
1011                                const nsAString &aPseudoClass)
1012 {
1013   EventStates state = GetStatesForPseudoClass(aPseudoClass);
1014   if (state.IsEmpty()) {
1015     return NS_OK;
1016   }
1017
1018   nsCOMPtr<mozilla::dom::Element> element = do_QueryInterface(aElement);
1019   NS_ENSURE_ARG_POINTER(element);
1020
1021   element->LockStyleStates(state);
1022
1023   return NS_OK;
1024 }
1025
1026 NS_IMETHODIMP
1027 inDOMUtils::RemovePseudoClassLock(nsIDOMElement *aElement,
1028                                   const nsAString &aPseudoClass)
1029 {
1030   EventStates state = GetStatesForPseudoClass(aPseudoClass);
1031   if (state.IsEmpty()) {
1032     return NS_OK;
1033   }
1034
1035   nsCOMPtr<mozilla::dom::Element> element = do_QueryInterface(aElement);
1036   NS_ENSURE_ARG_POINTER(element);
1037
1038   element->UnlockStyleStates(state);
1039
1040   return NS_OK;
1041 }
1042
1043 NS_IMETHODIMP
1044 inDOMUtils::HasPseudoClassLock(nsIDOMElement *aElement,
1045                                const nsAString &aPseudoClass,
1046                                bool *_retval)
1047 {
1048   EventStates state = GetStatesForPseudoClass(aPseudoClass);
1049   if (state.IsEmpty()) {
1050     *_retval = false;
1051     return NS_OK;
1052   }
1053
1054   nsCOMPtr<mozilla::dom::Element> element = do_QueryInterface(aElement);
1055   NS_ENSURE_ARG_POINTER(element);
1056
1057   EventStates locks = element->LockedStyleStates();
1058
1059   *_retval = locks.HasAllStates(state);
1060   return NS_OK;
1061 }
1062
1063 NS_IMETHODIMP
1064 inDOMUtils::ClearPseudoClassLocks(nsIDOMElement *aElement)
1065 {
1066   nsCOMPtr<mozilla::dom::Element> element = do_QueryInterface(aElement);
1067   NS_ENSURE_ARG_POINTER(element);
1068
1069   element->ClearStyleStateLocks();
1070
1071   return NS_OK;
1072 }
1073
1074 NS_IMETHODIMP
1075 inDOMUtils::ParseStyleSheet(nsIDOMCSSStyleSheet *aSheet,
1076                             const nsAString& aInput)
1077 {
1078   nsRefPtr<CSSStyleSheet> sheet = do_QueryObject(aSheet);
1079   NS_ENSURE_ARG_POINTER(sheet);
1080
1081   return sheet->ParseSheet(aInput);
1082 }
1083
1084 NS_IMETHODIMP
1085 inDOMUtils::ScrollElementIntoView(nsIDOMElement *aElement)
1086 {
1087   nsCOMPtr<nsIContent> content = do_QueryInterface(aElement);
1088   NS_ENSURE_ARG_POINTER(content);
1089
1090   nsIPresShell* presShell = content->OwnerDoc()->GetShell();
1091   if (!presShell) {
1092     return NS_OK;
1093   }
1094
1095   presShell->ScrollContentIntoView(content,
1096                                    nsIPresShell::ScrollAxis(),
1097                                    nsIPresShell::ScrollAxis(),
1098                                    nsIPresShell::SCROLL_OVERFLOW_HIDDEN);
1099
1100   return NS_OK;
1101 }