widget/nsNativeTheme.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 "nsNativeTheme.h"
   7 #include "nsIWidget.h"
   8 #include "mozilla/dom/Document.h"
   9 #include "nsIContent.h"
  10 #include "nsIFrame.h"
  11 #include "nsIScrollableFrame.h"
  12 #include "nsNumberControlFrame.h"
  13 #include "nsPresContext.h"
  14 #include "nsString.h"
  15 #include "nsNameSpaceManager.h"
  16 #include "nsStyleConsts.h"
  17 #include "nsPIDOMWindow.h"
  18 #include "nsProgressFrame.h"
  19 #include "nsMeterFrame.h"
  20 #include "nsMenuFrame.h"
  21 #include "nsRangeFrame.h"
  22 #include "nsCSSRendering.h"
  23 #include "ImageContainer.h"
  24 #include "mozilla/ComputedStyle.h"
  25 #include "mozilla/EventStates.h"
  26 #include "mozilla/dom/Element.h"
  27 #include "mozilla/dom/HTMLBodyElement.h"
  28 #include "mozilla/dom/HTMLInputElement.h"
  29 #include "mozilla/dom/HTMLProgressElement.h"
  30 #include "mozilla/PresShell.h"
  31 #include "mozilla/StaticPrefs_layout.h"
  32 #include "mozilla/dom/DocumentInlines.h"
  33 #include <algorithm>
  34
  35 using namespace mozilla;
  36 using namespace mozilla::dom;
  37
  38 nsNativeTheme::nsNativeTheme() : mAnimatedContentTimeout(UINT32_MAX) {}
  39
  40 NS_IMPL_ISUPPORTS(nsNativeTheme, nsITimerCallback, nsINamed)
  41
  42 /* static */ EventStates nsNativeTheme::GetContentState(
  43     nsIFrame* aFrame, StyleAppearance aAppearance) {
  44   if (!aFrame) return EventStates();
  45
  46   bool isXULCheckboxRadio = (aAppearance == StyleAppearance::Checkbox ||
  47                              aAppearance == StyleAppearance::Radio) &&
  48                             aFrame->GetContent()->IsXULElement();
  49   if (isXULCheckboxRadio) aFrame = aFrame->GetParent();
  50
  51   if (!aFrame->GetContent()) return EventStates();
  52
  53   nsIContent* frameContent = aFrame->GetContent();
  54   EventStates flags;
  55   if (frameContent->IsElement()) {
  56     flags = frameContent->AsElement()->State();
  57
  58     nsNumberControlFrame* numberControlFrame =
  59         nsNumberControlFrame::GetNumberControlFrameForSpinButton(aFrame);
  60     if (numberControlFrame &&
  61         numberControlFrame->GetContent()->AsElement()->State().HasState(
  62             NS_EVENT_STATE_DISABLED)) {
  63       flags |= NS_EVENT_STATE_DISABLED;
  64     }
  65   }
  66
  67   if (isXULCheckboxRadio && aAppearance == StyleAppearance::Radio &&
  68       IsFocused(aFrame)) {
  69     flags |= NS_EVENT_STATE_FOCUS;
  70     nsPIDOMWindowOuter* window = aFrame->GetContent()->OwnerDoc()->GetWindow();
  71     if (window && window->ShouldShowFocusRing()) {
  72       flags |= NS_EVENT_STATE_FOCUSRING;
  73     }
  74   }
  75
  76   return flags;
  77 }
  78
  79 /* static */
  80 bool nsNativeTheme::CheckBooleanAttr(nsIFrame* aFrame, nsAtom* aAtom) {
  81   if (!aFrame) return false;
  82
  83   nsIContent* content = aFrame->GetContent();
  84   if (!content || !content->IsElement()) return false;
  85
  86   if (content->IsHTMLElement())
  87     return content->AsElement()->HasAttr(kNameSpaceID_None, aAtom);
  88
  89   // For XML/XUL elements, an attribute must be equal to the literal
  90   // string "true" to be counted as true.  An empty string should _not_
  91   // be counted as true.
  92   return content->AsElement()->AttrValueIs(kNameSpaceID_None, aAtom, u"true"_ns,
  93                                            eCaseMatters);
  94 }
  95
  96 /* static */
  97 int32_t nsNativeTheme::CheckIntAttr(nsIFrame* aFrame, nsAtom* aAtom,
  98                                     int32_t defaultValue) {
  99   if (!aFrame) return defaultValue;
 100
 101   nsIContent* content = aFrame->GetContent();
 102   if (!content || !content->IsElement()) return defaultValue;
 103
 104   nsAutoString attr;
 105   content->AsElement()->GetAttr(kNameSpaceID_None, aAtom, attr);
 106   nsresult err;
 107   int32_t value = attr.ToInteger(&err);
 108   if (attr.IsEmpty() || NS_FAILED(err)) return defaultValue;
 109
 110   return value;
 111 }
 112
 113 /* static */
 114 double nsNativeTheme::GetProgressValue(nsIFrame* aFrame) {
 115   if (!aFrame || !aFrame->GetContent()->IsHTMLElement(nsGkAtoms::progress)) {
 116     return 0;
 117   }
 118
 119   return static_cast<HTMLProgressElement*>(aFrame->GetContent())->Value();
 120 }
 121
 122 /* static */
 123 double nsNativeTheme::GetProgressMaxValue(nsIFrame* aFrame) {
 124   if (!aFrame || !aFrame->GetContent()->IsHTMLElement(nsGkAtoms::progress)) {
 125     return 100;
 126   }
 127
 128   return static_cast<HTMLProgressElement*>(aFrame->GetContent())->Max();
 129 }
 130
 131 bool nsNativeTheme::GetCheckedOrSelected(nsIFrame* aFrame,
 132                                          bool aCheckSelected) {
 133   if (!aFrame) return false;
 134
 135   nsIContent* content = aFrame->GetContent();
 136
 137   if (content->IsXULElement()) {
 138     // For a XUL checkbox or radio button, the state of the parent determines
 139     // the checked state
 140     aFrame = aFrame->GetParent();
 141   } else {
 142     // Check for an HTML input element
 143     HTMLInputElement* inputElt = HTMLInputElement::FromNode(content);
 144     if (inputElt) {
 145       return inputElt->Checked();
 146     }
 147   }
 148
 149   return CheckBooleanAttr(
 150       aFrame, aCheckSelected ? nsGkAtoms::selected : nsGkAtoms::checked);
 151 }
 152
 153 bool nsNativeTheme::IsButtonTypeMenu(nsIFrame* aFrame) {
 154   if (!aFrame) return false;
 155
 156   nsIContent* content = aFrame->GetContent();
 157   return content->IsXULElement(nsGkAtoms::button) &&
 158          content->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
 159                                            u"menu"_ns, eCaseMatters);
 160 }
 161
 162 bool nsNativeTheme::IsPressedButton(nsIFrame* aFrame) {
 163   EventStates eventState =
 164       GetContentState(aFrame, StyleAppearance::Toolbarbutton);
 165   if (IsDisabled(aFrame, eventState)) return false;
 166
 167   return IsOpenButton(aFrame) ||
 168          eventState.HasAllStates(NS_EVENT_STATE_ACTIVE | NS_EVENT_STATE_HOVER);
 169 }
 170
 171 bool nsNativeTheme::GetIndeterminate(nsIFrame* aFrame) {
 172   if (!aFrame) return false;
 173
 174   nsIContent* content = aFrame->GetContent();
 175
 176   if (content->IsXULElement()) {
 177     // For a XUL checkbox or radio button, the state of the parent determines
 178     // the state
 179     return CheckBooleanAttr(aFrame->GetParent(), nsGkAtoms::indeterminate);
 180   }
 181
 182   // Check for an HTML input element
 183   HTMLInputElement* inputElt = HTMLInputElement::FromNode(content);
 184   if (inputElt) {
 185     return inputElt->Indeterminate();
 186   }
 187
 188   return false;
 189 }
 190
 191 bool nsNativeTheme::IsWidgetStyled(nsPresContext* aPresContext,
 192                                    nsIFrame* aFrame,
 193                                    StyleAppearance aAppearance) {
 194   // Check for specific widgets to see if HTML has overridden the style.
 195   if (!aFrame) return false;
 196
 197   // Resizers have some special handling, dependent on whether in a scrollable
 198   // container or not. If so, use the scrollable container's to determine
 199   // whether the style is overriden instead of the resizer. This allows a
 200   // non-native transparent resizer to be used instead. Otherwise, we just
 201   // fall through and return false.
 202   if (aAppearance == StyleAppearance::Resizer) {
 203     nsIFrame* parentFrame = aFrame->GetParent();
 204     if (parentFrame && parentFrame->IsScrollFrame()) {
 205       // if the parent is a scrollframe, the resizer should be native themed
 206       // only if the scrollable area doesn't override the widget style.
 207       parentFrame = parentFrame->GetParent();
 208       if (parentFrame) {
 209         return IsWidgetStyled(
 210             aPresContext, parentFrame,
 211             parentFrame->StyleDisplay()->EffectiveAppearance());
 212       }
 213     }
 214   }
 215
 216   /**
 217    * Progress bar appearance should be the same for the bar and the container
 218    * frame. nsProgressFrame owns the logic and will tell us what we should do.
 219    */
 220   if (aAppearance == StyleAppearance::Progresschunk ||
 221       aAppearance == StyleAppearance::ProgressBar) {
 222     nsProgressFrame* progressFrame = do_QueryFrame(
 223         aAppearance == StyleAppearance::Progresschunk ? aFrame->GetParent()
 224                                                       : aFrame);
 225     if (progressFrame) {
 226       return !progressFrame->ShouldUseNativeStyle();
 227     }
 228   }
 229
 230   /**
 231    * Meter bar appearance should be the same for the bar and the container
 232    * frame. nsMeterFrame owns the logic and will tell us what we should do.
 233    */
 234   if (aAppearance == StyleAppearance::Meterchunk ||
 235       aAppearance == StyleAppearance::Meter) {
 236     nsMeterFrame* meterFrame = do_QueryFrame(
 237         aAppearance == StyleAppearance::Meterchunk ? aFrame->GetParent()
 238                                                    : aFrame);
 239     if (meterFrame) {
 240       return !meterFrame->ShouldUseNativeStyle();
 241     }
 242   }
 243
 244   /**
 245    * An nsRangeFrame and its children are treated atomically when it
 246    * comes to native theming (either all parts, or no parts, are themed).
 247    * nsRangeFrame owns the logic and will tell us what we should do.
 248    */
 249   if (aAppearance == StyleAppearance::Range ||
 250       aAppearance == StyleAppearance::RangeThumb) {
 251     nsRangeFrame* rangeFrame = do_QueryFrame(
 252         aAppearance == StyleAppearance::RangeThumb ? aFrame->GetParent()
 253                                                    : aFrame);
 254     if (rangeFrame) {
 255       return !rangeFrame->ShouldUseNativeStyle();
 256     }
 257   }
 258
 259   if (aAppearance == StyleAppearance::SpinnerUpbutton ||
 260       aAppearance == StyleAppearance::SpinnerDownbutton) {
 261     nsNumberControlFrame* numberControlFrame =
 262         nsNumberControlFrame::GetNumberControlFrameForSpinButton(aFrame);
 263     if (numberControlFrame) {
 264       return !numberControlFrame->ShouldUseNativeStyleForSpinner();
 265     }
 266   }
 267
 268   return (aAppearance == StyleAppearance::NumberInput ||
 269           aAppearance == StyleAppearance::Button ||
 270           aAppearance == StyleAppearance::Textfield ||
 271           aAppearance == StyleAppearance::Textarea ||
 272           aAppearance == StyleAppearance::Listbox ||
 273           aAppearance == StyleAppearance::Menulist ||
 274           aAppearance == StyleAppearance::MenulistButton) &&
 275          aFrame->GetContent()->IsHTMLElement() &&
 276          aPresContext->HasAuthorSpecifiedRules(
 277              aFrame, NS_AUTHOR_SPECIFIED_BORDER_OR_BACKGROUND);
 278 }
 279
 280 bool nsNativeTheme::IsDisabled(nsIFrame* aFrame, EventStates aEventStates) {
 281   if (!aFrame) {
 282     return false;
 283   }
 284
 285   nsIContent* content = aFrame->GetContent();
 286   if (!content || !content->IsElement()) {
 287     return false;
 288   }
 289
 290   if (content->IsHTMLElement()) {
 291     return aEventStates.HasState(NS_EVENT_STATE_DISABLED);
 292   }
 293
 294   // For XML/XUL elements, an attribute must be equal to the literal
 295   // string "true" to be counted as true.  An empty string should _not_
 296   // be counted as true.
 297   return content->AsElement()->AttrValueIs(
 298       kNameSpaceID_None, nsGkAtoms::disabled, u"true"_ns, eCaseMatters);
 299 }
 300
 301 /* static */
 302 bool nsNativeTheme::IsFrameRTL(nsIFrame* aFrame) {
 303   if (!aFrame) {
 304     return false;
 305   }
 306   return aFrame->GetWritingMode().IsPhysicalRTL();
 307 }
 308
 309 /* static */
 310 bool nsNativeTheme::IsHTMLContent(nsIFrame* aFrame) {
 311   if (!aFrame) {
 312     return false;
 313   }
 314   nsIContent* content = aFrame->GetContent();
 315   return content && content->IsHTMLElement();
 316 }
 317
 318 // scrollbar button:
 319 int32_t nsNativeTheme::GetScrollbarButtonType(nsIFrame* aFrame) {
 320   if (!aFrame) return 0;
 321
 322   static Element::AttrValuesArray strings[] = {
 323       nsGkAtoms::scrollbarDownBottom, nsGkAtoms::scrollbarDownTop,
 324       nsGkAtoms::scrollbarUpBottom, nsGkAtoms::scrollbarUpTop, nullptr};
 325
 326   nsIContent* content = aFrame->GetContent();
 327   if (!content || !content->IsElement()) {
 328     return 0;
 329   }
 330
 331   switch (content->AsElement()->FindAttrValueIn(
 332       kNameSpaceID_None, nsGkAtoms::sbattr, strings, eCaseMatters)) {
 333     case 0:
 334       return eScrollbarButton_Down | eScrollbarButton_Bottom;
 335     case 1:
 336       return eScrollbarButton_Down;
 337     case 2:
 338       return eScrollbarButton_Bottom;
 339     case 3:
 340       return eScrollbarButton_UpTop;
 341   }
 342
 343   return 0;
 344 }
 345
 346 // treeheadercell:
 347 nsNativeTheme::TreeSortDirection nsNativeTheme::GetTreeSortDirection(
 348     nsIFrame* aFrame) {
 349   if (!aFrame || !aFrame->GetContent()) return eTreeSortDirection_Natural;
 350
 351   static Element::AttrValuesArray strings[] = {nsGkAtoms::descending,
 352                                                nsGkAtoms::ascending, nullptr};
 353
 354   nsIContent* content = aFrame->GetContent();
 355   if (content->IsElement()) {
 356     switch (content->AsElement()->FindAttrValueIn(
 357         kNameSpaceID_None, nsGkAtoms::sortDirection, strings, eCaseMatters)) {
 358       case 0:
 359         return eTreeSortDirection_Descending;
 360       case 1:
 361         return eTreeSortDirection_Ascending;
 362     }
 363   }
 364
 365   return eTreeSortDirection_Natural;
 366 }
 367
 368 bool nsNativeTheme::IsLastTreeHeaderCell(nsIFrame* aFrame) {
 369   if (!aFrame) return false;
 370
 371   // A tree column picker is always the last header cell.
 372   if (aFrame->GetContent()->IsXULElement(nsGkAtoms::treecolpicker)) return true;
 373
 374   // Find the parent tree.
 375   nsIContent* parent = aFrame->GetContent()->GetParent();
 376   while (parent && !parent->IsXULElement(nsGkAtoms::tree)) {
 377     parent = parent->GetParent();
 378   }
 379
 380   // If the column picker is visible, this can't be the last column.
 381   if (parent && !parent->AsElement()->AttrValueIs(kNameSpaceID_None,
 382                                                   nsGkAtoms::hidecolumnpicker,
 383                                                   u"true"_ns, eCaseMatters))
 384     return false;
 385
 386   while ((aFrame = aFrame->GetNextSibling())) {
 387     if (aFrame->GetRect().Width() > 0) return false;
 388   }
 389   return true;
 390 }
 391
 392 // tab:
 393 bool nsNativeTheme::IsBottomTab(nsIFrame* aFrame) {
 394   if (!aFrame) return false;
 395
 396   nsAutoString classStr;
 397   if (aFrame->GetContent()->IsElement()) {
 398     aFrame->GetContent()->AsElement()->GetAttr(kNameSpaceID_None,
 399                                                nsGkAtoms::_class, classStr);
 400   }
 401   // FIXME: This looks bogus, shouldn't this be looking at GetClasses()?
 402   return !classStr.IsEmpty() && classStr.Find("tab-bottom") != kNotFound;
 403 }
 404
 405 bool nsNativeTheme::IsFirstTab(nsIFrame* aFrame) {
 406   if (!aFrame) return false;
 407
 408   for (nsIFrame* first : aFrame->GetParent()->PrincipalChildList()) {
 409     if (first->GetRect().Width() > 0 &&
 410         first->GetContent()->IsXULElement(nsGkAtoms::tab))
 411       return (first == aFrame);
 412   }
 413   return false;
 414 }
 415
 416 bool nsNativeTheme::IsHorizontal(nsIFrame* aFrame) {
 417   if (!aFrame) return false;
 418
 419   if (!aFrame->GetContent()->IsElement()) return true;
 420
 421   return !aFrame->GetContent()->AsElement()->AttrValueIs(
 422       kNameSpaceID_None, nsGkAtoms::orient, nsGkAtoms::vertical, eCaseMatters);
 423 }
 424
 425 bool nsNativeTheme::IsNextToSelectedTab(nsIFrame* aFrame, int32_t aOffset) {
 426   if (!aFrame) return false;
 427
 428   if (aOffset == 0) return IsSelectedTab(aFrame);
 429
 430   int32_t thisTabIndex = -1, selectedTabIndex = -1;
 431
 432   nsIFrame* currentTab = aFrame->GetParent()->PrincipalChildList().FirstChild();
 433   for (int32_t i = 0; currentTab; currentTab = currentTab->GetNextSibling()) {
 434     if (currentTab->GetRect().Width() == 0) continue;
 435     if (aFrame == currentTab) thisTabIndex = i;
 436     if (IsSelectedTab(currentTab)) selectedTabIndex = i;
 437     ++i;
 438   }
 439
 440   if (thisTabIndex == -1 || selectedTabIndex == -1) return false;
 441
 442   return (thisTabIndex - selectedTabIndex == aOffset);
 443 }
 444
 445 bool nsNativeTheme::IsIndeterminateProgress(nsIFrame* aFrame,
 446                                             EventStates aEventStates) {
 447   if (!aFrame || !aFrame->GetContent() ||
 448       !aFrame->GetContent()->IsHTMLElement(nsGkAtoms::progress)) {
 449     return false;
 450   }
 451
 452   return aEventStates.HasState(NS_EVENT_STATE_INDETERMINATE);
 453 }
 454
 455 bool nsNativeTheme::IsVerticalProgress(nsIFrame* aFrame) {
 456   if (!aFrame) {
 457     return false;
 458   }
 459   return IsVerticalMeter(aFrame);
 460 }
 461
 462 bool nsNativeTheme::IsVerticalMeter(nsIFrame* aFrame) {
 463   MOZ_ASSERT(aFrame, "You have to pass a non-null aFrame");
 464   switch (aFrame->StyleDisplay()->mOrient) {
 465     case StyleOrient::Horizontal:
 466       return false;
 467     case StyleOrient::Vertical:
 468       return true;
 469     case StyleOrient::Inline:
 470       return aFrame->GetWritingMode().IsVertical();
 471     case StyleOrient::Block:
 472       return !aFrame->GetWritingMode().IsVertical();
 473   }
 474   MOZ_ASSERT_UNREACHABLE("unexpected -moz-orient value");
 475   return false;
 476 }
 477
 478 // menupopup:
 479 bool nsNativeTheme::IsSubmenu(nsIFrame* aFrame, bool* aLeftOfParent) {
 480   if (!aFrame) return false;
 481
 482   nsIContent* parentContent = aFrame->GetContent()->GetParent();
 483   if (!parentContent || !parentContent->IsXULElement(nsGkAtoms::menu))
 484     return false;
 485
 486   nsIFrame* parent = aFrame;
 487   while ((parent = parent->GetParent())) {
 488     if (parent->GetContent() == parentContent) {
 489       if (aLeftOfParent) {
 490         LayoutDeviceIntRect selfBounds, parentBounds;
 491         selfBounds = aFrame->GetNearestWidget()->GetScreenBounds();
 492         parentBounds = parent->GetNearestWidget()->GetScreenBounds();
 493         *aLeftOfParent = selfBounds.X() < parentBounds.X();
 494       }
 495       return true;
 496     }
 497   }
 498
 499   return false;
 500 }
 501
 502 bool nsNativeTheme::IsRegularMenuItem(nsIFrame* aFrame) {
 503   nsMenuFrame* menuFrame = do_QueryFrame(aFrame);
 504   return !(menuFrame &&
 505            (menuFrame->IsOnMenuBar() || menuFrame->IsParentMenuList()));
 506 }
 507
 508 bool nsNativeTheme::QueueAnimatedContentForRefresh(nsIContent* aContent,
 509                                                    uint32_t aMinimumFrameRate) {
 510   NS_ASSERTION(aContent, "Null pointer!");
 511   NS_ASSERTION(aMinimumFrameRate, "aMinimumFrameRate must be non-zero!");
 512   NS_ASSERTION(aMinimumFrameRate <= 1000,
 513                "aMinimumFrameRate must be less than 1000!");
 514
 515   uint32_t timeout = 1000 / aMinimumFrameRate;
 516   timeout = std::min(mAnimatedContentTimeout, timeout);
 517
 518   if (!mAnimatedContentTimer) {
 519     mAnimatedContentTimer = NS_NewTimer();
 520     NS_ENSURE_TRUE(mAnimatedContentTimer, false);
 521   }
 522
 523   if (mAnimatedContentList.IsEmpty() || timeout != mAnimatedContentTimeout) {
 524     nsresult rv;
 525     if (!mAnimatedContentList.IsEmpty()) {
 526       rv = mAnimatedContentTimer->Cancel();
 527       NS_ENSURE_SUCCESS(rv, false);
 528     }
 529
 530     if (XRE_IsContentProcess() && NS_IsMainThread()) {
 531       mAnimatedContentTimer->SetTarget(
 532           aContent->OwnerDoc()->EventTargetFor(TaskCategory::Other));
 533     }
 534     rv = mAnimatedContentTimer->InitWithCallback(this, timeout,
 535                                                  nsITimer::TYPE_ONE_SHOT);
 536     NS_ENSURE_SUCCESS(rv, false);
 537
 538     mAnimatedContentTimeout = timeout;
 539   }
 540
 541   // XXX(Bug 1631371) Check if this should use a fallible operation as it
 542   // pretended earlier.
 543   mAnimatedContentList.AppendElement(aContent);
 544
 545   return true;
 546 }
 547
 548 NS_IMETHODIMP
 549 nsNativeTheme::Notify(nsITimer* aTimer) {
 550   NS_ASSERTION(aTimer == mAnimatedContentTimer, "Wrong timer!");
 551
 552   // XXX Assumes that calling nsIFrame::Invalidate won't reenter
 553   //     QueueAnimatedContentForRefresh.
 554
 555   uint32_t count = mAnimatedContentList.Length();
 556   for (uint32_t index = 0; index < count; index++) {
 557     nsIFrame* frame = mAnimatedContentList[index]->GetPrimaryFrame();
 558     if (frame) {
 559       frame->InvalidateFrame();
 560     }
 561   }
 562
 563   mAnimatedContentList.Clear();
 564   mAnimatedContentTimeout = UINT32_MAX;
 565   return NS_OK;
 566 }
 567
 568 NS_IMETHODIMP
 569 nsNativeTheme::GetName(nsACString& aName) {
 570   aName.AssignLiteral("nsNativeTheme");
 571   return NS_OK;
 572 }
 573
 574 nsIFrame* nsNativeTheme::GetAdjacentSiblingFrameWithSameAppearance(
 575     nsIFrame* aFrame, bool aNextSibling) {
 576   if (!aFrame) return nullptr;
 577
 578   // Find the next visible sibling.
 579   nsIFrame* sibling = aFrame;
 580   do {
 581     sibling =
 582         aNextSibling ? sibling->GetNextSibling() : sibling->GetPrevSibling();
 583   } while (sibling && sibling->GetRect().Width() == 0);
 584
 585   // Check same appearance and adjacency.
 586   if (!sibling ||
 587       sibling->StyleDisplay()->EffectiveAppearance() !=
 588           aFrame->StyleDisplay()->EffectiveAppearance() ||
 589       (sibling->GetRect().XMost() != aFrame->GetRect().X() &&
 590        aFrame->GetRect().XMost() != sibling->GetRect().X()))
 591     return nullptr;
 592   return sibling;
 593 }
 594
 595 bool nsNativeTheme::IsRangeHorizontal(nsIFrame* aFrame) {
 596   nsIFrame* rangeFrame = aFrame;
 597   if (!rangeFrame->IsRangeFrame()) {
 598     // If the thumb's frame is passed in, get its range parent:
 599     rangeFrame = aFrame->GetParent();
 600   }
 601   if (rangeFrame->IsRangeFrame()) {
 602     return static_cast<nsRangeFrame*>(rangeFrame)->IsHorizontal();
 603   }
 604   // Not actually a range frame - just use the ratio of the frame's size to
 605   // decide:
 606   return aFrame->GetSize().width >= aFrame->GetSize().height;
 607 }
 608
 609 static nsIFrame* GetBodyFrame(nsIFrame* aCanvasFrame) {
 610   nsIContent* content = aCanvasFrame->GetContent();
 611   if (!content) {
 612     return nullptr;
 613   }
 614   nsIContent* body = content->OwnerDoc()->GetBodyElement();
 615   if (!body) {
 616     return nullptr;
 617   }
 618   return body->GetPrimaryFrame();
 619 }
 620
 621 /* static */
 622 bool nsNativeTheme::IsDarkBackground(nsIFrame* aFrame) {
 623   nsIScrollableFrame* scrollFrame = nullptr;
 624   while (!scrollFrame && aFrame) {
 625     scrollFrame = aFrame->GetScrollTargetFrame();
 626     aFrame = aFrame->GetParent();
 627   }
 628   if (!scrollFrame) return false;
 629
 630   nsIFrame* frame = scrollFrame->GetScrolledFrame();
 631   if (nsCSSRendering::IsCanvasFrame(frame)) {
 632     // For canvas frames, prefer to look at the body first, because the body
 633     // background color is most likely what will be visible as the background
 634     // color of the page, even if the html element has a different background
 635     // color which prevents that of the body frame to propagate to the viewport.
 636     nsIFrame* bodyFrame = GetBodyFrame(frame);
 637     if (bodyFrame) {
 638       frame = bodyFrame;
 639     }
 640   }
 641   ComputedStyle* bgSC = nullptr;
 642   if (!nsCSSRendering::FindBackground(frame, &bgSC) ||
 643       bgSC->StyleBackground()->IsTransparent(bgSC)) {
 644     nsIFrame* backgroundFrame =
 645         nsCSSRendering::FindNonTransparentBackgroundFrame(frame, true);
 646     nsCSSRendering::FindBackground(backgroundFrame, &bgSC);
 647   }
 648   if (bgSC) {
 649     nscolor bgColor = bgSC->StyleBackground()->BackgroundColor(bgSC);
 650     // Consider the background color dark if the sum of the r, g and b values is
 651     // less than 384 in a semi-transparent document.  This heuristic matches
 652     // what WebKit does, and we can improve it later if needed.
 653     return NS_GET_A(bgColor) > 127 &&
 654            NS_GET_R(bgColor) + NS_GET_G(bgColor) + NS_GET_B(bgColor) < 384;
 655   }
 656   return false;
 657 }
 658
 659 bool nsNativeTheme::IsWidgetScrollbarPart(StyleAppearance aAppearance) {
 660   switch (aAppearance) {
 661     case StyleAppearance::ScrollbarVertical:
 662     case StyleAppearance::ScrollbarHorizontal:
 663     case StyleAppearance::ScrollbarbuttonUp:
 664     case StyleAppearance::ScrollbarbuttonDown:
 665     case StyleAppearance::ScrollbarbuttonLeft:
 666     case StyleAppearance::ScrollbarbuttonRight:
 667     case StyleAppearance::ScrollbarthumbVertical:
 668     case StyleAppearance::ScrollbarthumbHorizontal:
 669     case StyleAppearance::ScrollbartrackHorizontal:
 670     case StyleAppearance::ScrollbartrackVertical:
 671     case StyleAppearance::Scrollcorner:
 672       return true;
 673     default:
 674       return false;
 675   }
 676 }