The Tor Browser: widget/xpwidgets/nsNativeTheme.cpp@44a2da4a2ab2 (annotated)

widget/xpwidgets/nsNativeTheme.cpp@44a2da4a2ab2 (annotated)

widget/xpwidgets/nsNativeTheme.cpp

Fri, 16 Jan 2015 04:50:19 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Fri, 16 Jan 2015 04:50:19 +0100
branch: TOR_BUG_9701
changeset 13: 44a2da4a2ab2
permissions: -rw-r--r--

Replace accessor implementation with direct member state manipulation, by
request https://trac.torproject.org/projects/tor/ticket/9701#comment:32

 /* -*- 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 "nsNativeTheme.h"
 #include "nsIWidget.h"
 #include "nsIDocument.h"
 #include "nsIContent.h"
 #include "nsIFrame.h"
 #include "nsIPresShell.h"
 #include "nsNumberControlFrame.h"
 #include "nsPresContext.h"
 #include "nsString.h"
 #include "nsNameSpaceManager.h"
 #include "nsIDOMHTMLInputElement.h"
 #include "nsIDOMXULMenuListElement.h"
 #include "nsThemeConstants.h"
 #include "nsIComponentManager.h"
 #include "nsPIDOMWindow.h"
 #include "nsProgressFrame.h"
 #include "nsMeterFrame.h"
 #include "nsMenuFrame.h"
 #include "nsRangeFrame.h"
 #include "nsCSSRendering.h"
 #include "mozilla/EventStates.h"
 #include "mozilla/dom/Element.h"
 #include "mozilla/dom/HTMLBodyElement.h"
 #include "mozilla/dom/HTMLProgressElement.h"
 #include "nsIDocumentInlines.h"
 #include <algorithm>
 using namespace mozilla;
 using namespace mozilla::dom;
 nsNativeTheme::nsNativeTheme()
 : mAnimatedContentTimeout(UINT32_MAX)
 {
 }
 NS_IMPL_ISUPPORTS(nsNativeTheme, nsITimerCallback)
 nsIPresShell *
 nsNativeTheme::GetPresShell(nsIFrame* aFrame)
 {
   if (!aFrame)
     return nullptr;
   // this is a workaround for the egcs 1.1.2 not inlining
   // aFrame->PresContext(), which causes an undefined symbol
   nsPresContext *context = aFrame->StyleContext()->RuleNode()->PresContext();
   return context ? context->GetPresShell() : nullptr;
 }
 EventStates
 nsNativeTheme::GetContentState(nsIFrame* aFrame, uint8_t aWidgetType)
 {
   if (!aFrame)
     return EventStates();
   bool isXULCheckboxRadio =
     (aWidgetType == NS_THEME_CHECKBOX ||
      aWidgetType == NS_THEME_RADIO) &&
     aFrame->GetContent()->IsXUL();
   if (isXULCheckboxRadio)
     aFrame = aFrame->GetParent();
   if (!aFrame->GetContent())
     return EventStates();
   nsIPresShell *shell = GetPresShell(aFrame);
   if (!shell)
     return EventStates();
   nsIContent* frameContent = aFrame->GetContent();
   EventStates flags;
   if (frameContent->IsElement()) {
     flags = frameContent->AsElement()->State();
     // <input type=number> needs special handling since its nested native
     // anonymous <input type=text> takes focus for it.
     if (aWidgetType == NS_THEME_NUMBER_INPUT &&
         frameContent->IsHTML(nsGkAtoms::input)) {
       nsNumberControlFrame *numberControlFrame = do_QueryFrame(aFrame);
       if (numberControlFrame && numberControlFrame->IsFocused()) {
         flags |= NS_EVENT_STATE_FOCUS;
       }
     }
     nsNumberControlFrame* numberControlFrame =
       nsNumberControlFrame::GetNumberControlFrameForSpinButton(aFrame);
     if (numberControlFrame &&
         numberControlFrame->GetContent()->AsElement()->State().
           HasState(NS_EVENT_STATE_DISABLED)) {
       flags |= NS_EVENT_STATE_DISABLED;
     }
   }
   if (isXULCheckboxRadio && aWidgetType == NS_THEME_RADIO) {
     if (IsFocused(aFrame))
       flags |= NS_EVENT_STATE_FOCUS;
   }
   // On Windows and Mac, only draw focus rings if they should be shown. This
   // means that focus rings are only shown once the keyboard has been used to
   // focus something in the window.
 #if defined(XP_MACOSX)
   // Mac always draws focus rings for textboxes and lists.
   if (aWidgetType == NS_THEME_NUMBER_INPUT ||
       aWidgetType == NS_THEME_TEXTFIELD ||
       aWidgetType == NS_THEME_TEXTFIELD_MULTILINE ||
       aWidgetType == NS_THEME_SEARCHFIELD ||
       aWidgetType == NS_THEME_LISTBOX) {
     return flags;
   }
 #endif
 #if defined(XP_WIN)
   // On Windows, focused buttons are always drawn as such by the native theme.
   if (aWidgetType == NS_THEME_BUTTON)
     return flags;
 #endif
 #if defined(XP_MACOSX) || defined(XP_WIN)
   nsIDocument* doc = aFrame->GetContent()->OwnerDoc();
   nsPIDOMWindow* window = doc->GetWindow();
   if (window && !window->ShouldShowFocusRing())
     flags &= ~NS_EVENT_STATE_FOCUS;
 #endif
   return flags;
 }
 /* static */
 bool
 nsNativeTheme::CheckBooleanAttr(nsIFrame* aFrame, nsIAtom* aAtom)
 {
   if (!aFrame)
     return false;
   nsIContent* content = aFrame->GetContent();
   if (!content)
     return false;
   if (content->IsHTML())
     return content->HasAttr(kNameSpaceID_None, aAtom);
   // For XML/XUL elements, an attribute must be equal to the literal
   // string "true" to be counted as true.  An empty string should _not_
   // be counted as true.
   return content->AttrValueIs(kNameSpaceID_None, aAtom,
                               NS_LITERAL_STRING("true"), eCaseMatters);
 }
 /* static */
 int32_t
 nsNativeTheme::CheckIntAttr(nsIFrame* aFrame, nsIAtom* aAtom, int32_t defaultValue)
 {
   if (!aFrame)
     return defaultValue;
   nsAutoString attr;
   aFrame->GetContent()->GetAttr(kNameSpaceID_None, aAtom, attr);
   nsresult err;
   int32_t value = attr.ToInteger(&err);
   if (attr.IsEmpty() || NS_FAILED(err))
     return defaultValue;
   return value;
 }
 /* static */
 double
 nsNativeTheme::GetProgressValue(nsIFrame* aFrame)
 {
   // When we are using the HTML progress element,
   // we can get the value from the IDL property.
   if (aFrame && aFrame->GetContent()->IsHTML(nsGkAtoms::progress)) {
     return static_cast<HTMLProgressElement*>(aFrame->GetContent())->Value();
   }
   return (double)nsNativeTheme::CheckIntAttr(aFrame, nsGkAtoms::value, 0);
 }
 /* static */
 double
 nsNativeTheme::GetProgressMaxValue(nsIFrame* aFrame)
 {
   // When we are using the HTML progress element,
   // we can get the max from the IDL property.
   if (aFrame && aFrame->GetContent()->IsHTML(nsGkAtoms::progress)) {
     return static_cast<HTMLProgressElement*>(aFrame->GetContent())->Max();
   }
   return (double)std::max(nsNativeTheme::CheckIntAttr(aFrame, nsGkAtoms::max, 100), 1);
 }
 bool
 nsNativeTheme::GetCheckedOrSelected(nsIFrame* aFrame, bool aCheckSelected)
 {
   if (!aFrame)
     return false;
   nsIContent* content = aFrame->GetContent();
   if (content->IsXUL()) {
     // For a XUL checkbox or radio button, the state of the parent determines
     // the checked state
     aFrame = aFrame->GetParent();
   } else {
     // Check for an HTML input element
     nsCOMPtr<nsIDOMHTMLInputElement> inputElt = do_QueryInterface(content);
     if (inputElt) {
       bool checked;
       inputElt->GetChecked(&checked);
       return checked;
     }
   }
   return CheckBooleanAttr(aFrame, aCheckSelected ? nsGkAtoms::selected
                                                  : nsGkAtoms::checked);
 }
 bool
 nsNativeTheme::IsButtonTypeMenu(nsIFrame* aFrame)
 {
   if (!aFrame)
     return false;
   nsIContent* content = aFrame->GetContent();
   return content->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
                               NS_LITERAL_STRING("menu"), eCaseMatters);
 }
 bool
 nsNativeTheme::IsPressedButton(nsIFrame* aFrame)
 {
   EventStates eventState = GetContentState(aFrame, NS_THEME_TOOLBAR_BUTTON);
   if (IsDisabled(aFrame, eventState))
     return false;
   return IsOpenButton(aFrame) ||
          eventState.HasAllStates(NS_EVENT_STATE_ACTIVE | NS_EVENT_STATE_HOVER);
 }
 bool
 nsNativeTheme::GetIndeterminate(nsIFrame* aFrame)
 {
   if (!aFrame)
     return false;
   nsIContent* content = aFrame->GetContent();
   if (content->IsXUL()) {
     // For a XUL checkbox or radio button, the state of the parent determines
     // the state
     return CheckBooleanAttr(aFrame->GetParent(), nsGkAtoms::indeterminate);
   }
   // Check for an HTML input element
   nsCOMPtr<nsIDOMHTMLInputElement> inputElt = do_QueryInterface(content);
   if (inputElt) {
     bool indeterminate;
     inputElt->GetIndeterminate(&indeterminate);
     return indeterminate;
   }
   return false;
 }
 bool
 nsNativeTheme::IsWidgetStyled(nsPresContext* aPresContext, nsIFrame* aFrame,
                               uint8_t aWidgetType)
 {
   // Check for specific widgets to see if HTML has overridden the style.
   if (!aFrame)
     return false;
   // Resizers have some special handling, dependent on whether in a scrollable
   // container or not. If so, use the scrollable container's to determine
   // whether the style is overriden instead of the resizer. This allows a
   // non-native transparent resizer to be used instead. Otherwise, we just
   // fall through and return false.
   if (aWidgetType == NS_THEME_RESIZER) {
     nsIFrame* parentFrame = aFrame->GetParent();
     if (parentFrame && parentFrame->GetType() == nsGkAtoms::scrollFrame) {
       // if the parent is a scrollframe, the resizer should be native themed
       // only if the scrollable area doesn't override the widget style.
       parentFrame = parentFrame->GetParent();
       if (parentFrame) {
         return IsWidgetStyled(aPresContext, parentFrame,
                               parentFrame->StyleDisplay()->mAppearance);
       }
     }
   }
   /**
    * Progress bar appearance should be the same for the bar and the container
    * frame. nsProgressFrame owns the logic and will tell us what we should do.
    */
   if (aWidgetType == NS_THEME_PROGRESSBAR_CHUNK ||
       aWidgetType == NS_THEME_PROGRESSBAR) {
     nsProgressFrame* progressFrame = do_QueryFrame(aWidgetType == NS_THEME_PROGRESSBAR_CHUNK
                                        ? aFrame->GetParent() : aFrame);
     if (progressFrame) {
       return !progressFrame->ShouldUseNativeStyle();
     }
   }
   /**
    * Meter bar appearance should be the same for the bar and the container
    * frame. nsMeterFrame owns the logic and will tell us what we should do.
    */
   if (aWidgetType == NS_THEME_METERBAR_CHUNK ||
       aWidgetType == NS_THEME_METERBAR) {
     nsMeterFrame* meterFrame = do_QueryFrame(aWidgetType == NS_THEME_METERBAR_CHUNK
                                        ? aFrame->GetParent() : aFrame);
     if (meterFrame) {
       return !meterFrame->ShouldUseNativeStyle();
     }
   }
   /**
    * An nsRangeFrame and its children are treated atomically when it
    * comes to native theming (either all parts, or no parts, are themed).
    * nsRangeFrame owns the logic and will tell us what we should do.
    */
   if (aWidgetType == NS_THEME_RANGE ||
       aWidgetType == NS_THEME_RANGE_THUMB) {
     nsRangeFrame* rangeFrame =
       do_QueryFrame(aWidgetType == NS_THEME_RANGE_THUMB
                       ? aFrame->GetParent() : aFrame);
     if (rangeFrame) {
       return !rangeFrame->ShouldUseNativeStyle();
     }
   }
   if (aWidgetType == NS_THEME_SPINNER_UP_BUTTON ||
       aWidgetType == NS_THEME_SPINNER_DOWN_BUTTON) {
     nsNumberControlFrame* numberControlFrame =
       nsNumberControlFrame::GetNumberControlFrameForSpinButton(aFrame);
     if (numberControlFrame) {
       return !numberControlFrame->ShouldUseNativeStyleForSpinner();
     }
   }
   return (aWidgetType == NS_THEME_NUMBER_INPUT ||
           aWidgetType == NS_THEME_BUTTON ||
           aWidgetType == NS_THEME_TEXTFIELD ||
           aWidgetType == NS_THEME_TEXTFIELD_MULTILINE ||
           aWidgetType == NS_THEME_LISTBOX ||
           aWidgetType == NS_THEME_DROPDOWN) &&
          aFrame->GetContent()->IsHTML() &&
          aPresContext->HasAuthorSpecifiedRules(aFrame,
                                                NS_AUTHOR_SPECIFIED_BORDER |
                                                NS_AUTHOR_SPECIFIED_BACKGROUND);
 }
 bool
 nsNativeTheme::IsDisabled(nsIFrame* aFrame, EventStates aEventStates)
 {
   if (!aFrame) {
     return false;
   }
   nsIContent* content = aFrame->GetContent();
   if (!content) {
     return false;
   }
   if (content->IsHTML()) {
     return aEventStates.HasState(NS_EVENT_STATE_DISABLED);
   }
   // For XML/XUL elements, an attribute must be equal to the literal
   // string "true" to be counted as true.  An empty string should _not_
   // be counted as true.
   return content->AttrValueIs(kNameSpaceID_None, nsGkAtoms::disabled,
                               NS_LITERAL_STRING("true"), eCaseMatters);
 }
 bool
 nsNativeTheme::IsFrameRTL(nsIFrame* aFrame)
 {
   return aFrame && aFrame->StyleVisibility()->mDirection == NS_STYLE_DIRECTION_RTL;
 }
 bool
 nsNativeTheme::IsHTMLContent(nsIFrame *aFrame)
 {
   if (!aFrame) {
     return false;
   }
   nsIContent* content = aFrame->GetContent();
   return content && content->IsHTML();
 }
 // scrollbar button:
 int32_t
 nsNativeTheme::GetScrollbarButtonType(nsIFrame* aFrame)
 {
   if (!aFrame)
     return 0;
   static nsIContent::AttrValuesArray strings[] =
     {&nsGkAtoms::scrollbarDownBottom, &nsGkAtoms::scrollbarDownTop,
      &nsGkAtoms::scrollbarUpBottom, &nsGkAtoms::scrollbarUpTop,
      nullptr};
   switch (aFrame->GetContent()->FindAttrValueIn(kNameSpaceID_None,
                                                 nsGkAtoms::sbattr,
                                                 strings, eCaseMatters)) {
     case 0: return eScrollbarButton_Down | eScrollbarButton_Bottom;
     case 1: return eScrollbarButton_Down;
     case 2: return eScrollbarButton_Bottom;
     case 3: return eScrollbarButton_UpTop;
   }
   return 0;
 }
 // treeheadercell:
 nsNativeTheme::TreeSortDirection
 nsNativeTheme::GetTreeSortDirection(nsIFrame* aFrame)
 {
   if (!aFrame || !aFrame->GetContent())
     return eTreeSortDirection_Natural;
   static nsIContent::AttrValuesArray strings[] =
     {&nsGkAtoms::descending, &nsGkAtoms::ascending, nullptr};
   switch (aFrame->GetContent()->FindAttrValueIn(kNameSpaceID_None,
                                                 nsGkAtoms::sortDirection,
                                                 strings, eCaseMatters)) {
     case 0: return eTreeSortDirection_Descending;
     case 1: return eTreeSortDirection_Ascending;
   }
   return eTreeSortDirection_Natural;
 }
 bool
 nsNativeTheme::IsLastTreeHeaderCell(nsIFrame* aFrame)
 {
   if (!aFrame)
     return false;
   // A tree column picker is always the last header cell.
   if (aFrame->GetContent()->Tag() == nsGkAtoms::treecolpicker)
     return true;
   // Find the parent tree.
   nsIContent* parent = aFrame->GetContent()->GetParent();
   while (parent && parent->Tag() != nsGkAtoms::tree) {
     parent = parent->GetParent();
   }
   // If the column picker is visible, this can't be the last column.
   if (parent && !parent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::hidecolumnpicker,
                                      NS_LITERAL_STRING("true"), eCaseMatters))
     return false;
   while ((aFrame = aFrame->GetNextSibling())) {
     if (aFrame->GetRect().width > 0)
       return false;
   }
   return true;
 }
 // tab:
 bool
 nsNativeTheme::IsBottomTab(nsIFrame* aFrame)
 {
   if (!aFrame)
     return false;
   nsAutoString classStr;
   aFrame->GetContent()->GetAttr(kNameSpaceID_None, nsGkAtoms::_class, classStr);
   return !classStr.IsEmpty() && classStr.Find("tab-bottom") != kNotFound;
 }
 bool
 nsNativeTheme::IsFirstTab(nsIFrame* aFrame)
 {
   if (!aFrame)
     return false;
   nsIFrame* first = aFrame->GetParent()->GetFirstPrincipalChild();
   while (first) {
     if (first->GetRect().width > 0 && first->GetContent()->Tag() == nsGkAtoms::tab)
       return (first == aFrame);
     first = first->GetNextSibling();
   }
   return false;
 }
 bool
 nsNativeTheme::IsHorizontal(nsIFrame* aFrame)
 {
   if (!aFrame)
     return false;
   return !aFrame->GetContent()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::orient,
                                             nsGkAtoms::vertical,
                                             eCaseMatters);
 }
 bool
 nsNativeTheme::IsNextToSelectedTab(nsIFrame* aFrame, int32_t aOffset)
 {
   if (!aFrame)
     return false;
   if (aOffset == 0)
     return IsSelectedTab(aFrame);
   int32_t thisTabIndex = -1, selectedTabIndex = -1;
   nsIFrame* currentTab = aFrame->GetParent()->GetFirstPrincipalChild();
   for (int32_t i = 0; currentTab; currentTab = currentTab->GetNextSibling()) {
     if (currentTab->GetRect().width == 0)
       continue;
     if (aFrame == currentTab)
       thisTabIndex = i;
     if (IsSelectedTab(currentTab))
       selectedTabIndex = i;
     ++i;
   }
   if (thisTabIndex == -1 || selectedTabIndex == -1)
     return false;
   return (thisTabIndex - selectedTabIndex == aOffset);
 }
 // progressbar:
 bool
 nsNativeTheme::IsIndeterminateProgress(nsIFrame* aFrame,
                                        EventStates aEventStates)
 {
   if (!aFrame || !aFrame->GetContent())
     return false;
   if (aFrame->GetContent()->IsHTML(nsGkAtoms::progress)) {
     return aEventStates.HasState(NS_EVENT_STATE_INDETERMINATE);
   }
   return aFrame->GetContent()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::mode,
                                            NS_LITERAL_STRING("undetermined"),
                                            eCaseMatters);
 }
 bool
 nsNativeTheme::IsVerticalProgress(nsIFrame* aFrame)
 {
   return aFrame &&
          aFrame->StyleDisplay()->mOrient == NS_STYLE_ORIENT_VERTICAL;
 }
 bool
 nsNativeTheme::IsVerticalMeter(nsIFrame* aFrame)
 {
   NS_PRECONDITION(aFrame, "You have to pass a non-null aFrame");
   return aFrame->StyleDisplay()->mOrient == NS_STYLE_ORIENT_VERTICAL;
 }
 // menupopup:
 bool
 nsNativeTheme::IsSubmenu(nsIFrame* aFrame, bool* aLeftOfParent)
 {
   if (!aFrame)
     return false;
   nsIContent* parentContent = aFrame->GetContent()->GetParent();
   if (!parentContent || parentContent->Tag() != nsGkAtoms::menu)
     return false;
   nsIFrame* parent = aFrame;
   while ((parent = parent->GetParent())) {
     if (parent->GetContent() == parentContent) {
       if (aLeftOfParent) {
         nsIntRect selfBounds, parentBounds;
         aFrame->GetNearestWidget()->GetScreenBounds(selfBounds);
         parent->GetNearestWidget()->GetScreenBounds(parentBounds);
         *aLeftOfParent = selfBounds.x < parentBounds.x;
       }
       return true;
     }
   }
   return false;
 }
 bool
 nsNativeTheme::IsRegularMenuItem(nsIFrame *aFrame)
 {
   nsMenuFrame *menuFrame = do_QueryFrame(aFrame);
   return !(menuFrame && (menuFrame->IsOnMenuBar() ||
                          menuFrame->GetParentMenuListType() != eNotMenuList));
 }
 bool
 nsNativeTheme::IsMenuListEditable(nsIFrame *aFrame)
 {
   bool isEditable = false;
   nsCOMPtr<nsIDOMXULMenuListElement> menulist = do_QueryInterface(aFrame->GetContent());
   if (menulist)
     menulist->GetEditable(&isEditable);
   return isEditable;
 }
 bool
 nsNativeTheme::QueueAnimatedContentForRefresh(nsIContent* aContent,
                                               uint32_t aMinimumFrameRate)
 {
   NS_ASSERTION(aContent, "Null pointer!");
   NS_ASSERTION(aMinimumFrameRate, "aMinimumFrameRate must be non-zero!");
   NS_ASSERTION(aMinimumFrameRate <= 1000,
                "aMinimumFrameRate must be less than 1000!");
   uint32_t timeout = 1000 / aMinimumFrameRate;
   timeout = std::min(mAnimatedContentTimeout, timeout);
   if (!mAnimatedContentTimer) {
     mAnimatedContentTimer = do_CreateInstance(NS_TIMER_CONTRACTID);
     NS_ENSURE_TRUE(mAnimatedContentTimer, false);
   }
   if (mAnimatedContentList.IsEmpty() || timeout != mAnimatedContentTimeout) {
     nsresult rv;
     if (!mAnimatedContentList.IsEmpty()) {
       rv = mAnimatedContentTimer->Cancel();
       NS_ENSURE_SUCCESS(rv, false);
     }
     rv = mAnimatedContentTimer->InitWithCallback(this, timeout,
                                                  nsITimer::TYPE_ONE_SHOT);
     NS_ENSURE_SUCCESS(rv, false);
     mAnimatedContentTimeout = timeout;
   }
   if (!mAnimatedContentList.AppendElement(aContent)) {
     NS_WARNING("Out of memory!");
     return false;
   }
   return true;
 }
 NS_IMETHODIMP
 nsNativeTheme::Notify(nsITimer* aTimer)
 {
   NS_ASSERTION(aTimer == mAnimatedContentTimer, "Wrong timer!");
   // XXX Assumes that calling nsIFrame::Invalidate won't reenter
   //     QueueAnimatedContentForRefresh.
   uint32_t count = mAnimatedContentList.Length();
   for (uint32_t index = 0; index < count; index++) {
     nsIFrame* frame = mAnimatedContentList[index]->GetPrimaryFrame();
     if (frame) {
       frame->InvalidateFrame();
     }
   }
   mAnimatedContentList.Clear();
   mAnimatedContentTimeout = UINT32_MAX;
   return NS_OK;
 }
 nsIFrame*
 nsNativeTheme::GetAdjacentSiblingFrameWithSameAppearance(nsIFrame* aFrame,
                                                          bool aNextSibling)
 {
   if (!aFrame)
     return nullptr;
   // Find the next visible sibling.
   nsIFrame* sibling = aFrame;
   do {
     sibling = aNextSibling ? sibling->GetNextSibling() : sibling->GetPrevSibling();
   } while (sibling && sibling->GetRect().width == 0);
   // Check same appearance and adjacency.
   if (!sibling ||
       sibling->StyleDisplay()->mAppearance != aFrame->StyleDisplay()->mAppearance ||
       (sibling->GetRect().XMost() != aFrame->GetRect().x &&
        aFrame->GetRect().XMost() != sibling->GetRect().x))
     return nullptr;
   return sibling;
 }
 bool
 nsNativeTheme::IsRangeHorizontal(nsIFrame* aFrame)
 {
   nsIFrame* rangeFrame = aFrame;
   if (rangeFrame->GetType() != nsGkAtoms::rangeFrame) {
     // If the thumb's frame is passed in, get its range parent:
     rangeFrame = aFrame->GetParent();
   }
   if (rangeFrame->GetType() == nsGkAtoms::rangeFrame) {
     return static_cast<nsRangeFrame*>(rangeFrame)->IsHorizontal();
   }
   // Not actually a range frame - just use the ratio of the frame's size to
   // decide:
   return aFrame->GetSize().width >= aFrame->GetSize().height;
 }
 static nsIFrame*
 GetBodyFrame(nsIFrame* aCanvasFrame)
 {
   nsIContent* content = aCanvasFrame->GetContent();
   if (!content) {
     return nullptr;
   }
   nsIDocument* document = content->OwnerDoc();
   nsIContent* body = document->GetBodyElement();
   if (!body) {
     return nullptr;
   }
   return body->GetPrimaryFrame();
 }
 bool
 nsNativeTheme::IsDarkBackground(nsIFrame* aFrame)
 {
   nsIScrollableFrame* scrollFrame = nullptr;
   while (!scrollFrame && aFrame) {
     scrollFrame = aFrame->GetScrollTargetFrame();
     aFrame = aFrame->GetParent();
   }
   if (!scrollFrame)
     return false;
   nsIFrame* frame = scrollFrame->GetScrolledFrame();
   if (nsCSSRendering::IsCanvasFrame(frame)) {
     // For canvas frames, prefer to look at the body first, because the body
     // background color is most likely what will be visible as the background
     // color of the page, even if the html element has a different background
     // color which prevents that of the body frame to propagate to the viewport.
     nsIFrame* bodyFrame = GetBodyFrame(frame);
     if (bodyFrame) {
       frame = bodyFrame;
     }
   }
   nsStyleContext* bgSC = nullptr;
   if (!nsCSSRendering::FindBackground(frame, &bgSC) ||
       bgSC->StyleBackground()->IsTransparent()) {
     nsIFrame* backgroundFrame = nsCSSRendering::FindNonTransparentBackgroundFrame(frame, true);
     nsCSSRendering::FindBackground(backgroundFrame, &bgSC);
   }
   if (bgSC) {
     nscolor bgColor = bgSC->StyleBackground()->mBackgroundColor;
     // Consider the background color dark if the sum of the r, g and b values is
     // less than 384 in a semi-transparent document.  This heuristic matches what
     // WebKit does, and we can improve it later if needed.
     return NS_GET_A(bgColor) > 127 &&
            NS_GET_R(bgColor) + NS_GET_G(bgColor) + NS_GET_B(bgColor) < 384;
   }
   return false;
 }

The Tor Browser / annotate

widget/xpwidgets/nsNativeTheme.cpp@44a2da4a2ab2 (annotated)

widget/xpwidgets/nsNativeTheme.cpp