--- a/accessible/base/TextAttrs.cpp
+++ b/accessible/base/TextAttrs.cpp
@@ -455,18 +455,18 @@ TextAttrsMgr::FontFamilyTextAttr::
{
nsAccUtils::SetAccAttr(aAttributes, nsGkAtoms::font_family, aValue);
}
bool
TextAttrsMgr::FontFamilyTextAttr::
GetFontFamily(nsIFrame* aFrame, nsString& aFamily)
{
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetFontMetricsForFrame(aFrame, getter_AddRefs(fm), 1.0f);
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetFontMetricsForFrame(aFrame, 1.0f);
gfxFontGroup* fontGroup = fm->GetThebesFontGroup();
gfxFont* font = fontGroup->GetFirstValidFont();
gfxFontEntry* fontEntry = font->GetFontEntry();
aFamily = fontEntry->FamilyName();
return true;
}
@@ -613,18 +613,18 @@ TextAttrsMgr::FontWeightTextAttr::
}
int32_t
TextAttrsMgr::FontWeightTextAttr::
GetFontWeight(nsIFrame* aFrame)
{
// nsFont::width isn't suitable here because it's necessary to expose real
// value of font weight (used font might not have some font weight values).
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetFontMetricsForFrame(aFrame, getter_AddRefs(fm), 1.0f);
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetFontMetricsForFrame(aFrame, 1.0f);
gfxFontGroup *fontGroup = fm->GetThebesFontGroup();
gfxFont *font = fontGroup->GetFirstValidFont();
// When there doesn't exist a bold font in the family and so the rendering of
// a non-bold font face is changed so that the user sees what looks like a
// bold font, i.e. synthetic bolding is used. IsSyntheticBold method is only
// needed on Mac, but it is "safe" to use on all platforms. (For non-Mac
--- a/accessible/windows/sdn/sdnTextAccessible.cpp
+++ b/accessible/windows/sdn/sdnTextAccessible.cpp
@@ -174,18 +174,18 @@ sdnTextAccessible::get_fontFamily(BSTR _
if (mAccessible->IsDefunct())
return CO_E_OBJNOTCONNECTED;
nsIFrame* frame = mAccessible->GetFrame();
if (!frame)
return E_FAIL;
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetFontMetricsForFrame(frame, getter_AddRefs(fm), 1.0f);
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetFontMetricsForFrame(frame, 1.0f);
const nsString& name =
fm->GetThebesFontGroup()->GetFirstValidFont()->GetName();
if (name.IsEmpty())
return S_FALSE;
*aFontFamily = ::SysAllocStringLen(name.get(), name.Length());
return *aFontFamily ? S_OK : E_OUTOFMEMORY;
--- a/dom/canvas/CanvasRenderingContext2D.cpp
+++ b/dom/canvas/CanvasRenderingContext2D.cpp
@@ -2463,23 +2463,22 @@ public:
virtual float GetEmLength() const override
{
return NSAppUnitsToFloatPixels(mFont.size,
nsPresContext::AppUnitsPerCSSPixel());
}
virtual float GetExLength() const override
{
- RefPtr<nsFontMetrics> fontMetrics;
nsDeviceContext* dc = mPresContext->DeviceContext();
nsFontMetrics::Params params;
params.language = mFontLanguage;
params.explicitLanguage = mExplicitLanguage;
params.textPerf = mPresContext->GetTextPerfMetrics();
- dc->GetMetricsFor(mFont, params, *getter_AddRefs(fontMetrics));
+ RefPtr<nsFontMetrics> fontMetrics = dc->GetMetricsFor(mFont, params);
return NSAppUnitsToFloatPixels(fontMetrics->XHeight(),
nsPresContext::AppUnitsPerCSSPixel());
}
virtual gfx::Size GetSize() const override
{ return Size(mSize); }
private:
@@ -3231,19 +3230,18 @@ CanvasRenderingContext2D::SetFontInterna
resizedFont.size =
(fontStyle->mSize * c->AppUnitsPerDevPixel()) / c->AppUnitsPerCSSPixel();
nsFontMetrics::Params params;
params.language = fontStyle->mLanguage;
params.explicitLanguage = fontStyle->mExplicitLanguage;
params.userFontSet = c->GetUserFontSet();
params.textPerf = c->GetTextPerfMetrics();
- RefPtr<nsFontMetrics> metrics;
- c->DeviceContext()->GetMetricsFor(resizedFont, params,
- *getter_AddRefs(metrics));
+ RefPtr<nsFontMetrics> metrics =
+ c->DeviceContext()->GetMetricsFor(resizedFont, params);
gfxFontGroup* newFontGroup = metrics->GetThebesFontGroup();
CurrentState().fontGroup = newFontGroup;
NS_ASSERTION(CurrentState().fontGroup, "Could not get font group");
CurrentState().font = usedFont;
CurrentState().fontFont = fontStyle->mFont;
CurrentState().fontFont.size = fontStyle->mSize;
CurrentState().fontLanguage = fontStyle->mLanguage;
--- a/dom/events/ContentEventHandler.cpp
+++ b/dom/events/ContentEventHandler.cpp
@@ -1448,32 +1448,24 @@ ContentEventHandler::OnQueryCaretRect(Wi
aEvent->mReply.mWritingMode = frame->GetWritingMode();
bool isVertical = aEvent->mReply.mWritingMode.IsVertical();
nsRect rect;
rect.x = posInFrame.x;
rect.y = posInFrame.y;
- nscoord fontHeight = 0;
- RefPtr<nsFontMetrics> fontMetrics;
- rv = nsLayoutUtils::
- GetInflatedFontMetricsForFrame(frame, getter_AddRefs(fontMetrics));
- if (NS_WARN_IF(!fontMetrics)) {
- // If we cannot get font height, use frame size instead.
- fontHeight = isVertical ? frame->GetSize().width : frame->GetSize().height;
- } else {
- fontHeight = fontMetrics->MaxAscent() + fontMetrics->MaxDescent();
- }
+ RefPtr<nsFontMetrics> fontMetrics =
+ nsLayoutUtils::GetInflatedFontMetricsForFrame(frame);
if (isVertical) {
- rect.width = fontHeight;
+ rect.width = fontMetrics->MaxHeight();
rect.height = caretRect.height;
} else {
rect.width = caretRect.width;
- rect.height = fontHeight;
+ rect.height = fontMetrics->MaxHeight();
}
rv = ConvertToRootRelativeOffset(frame, rect);
NS_ENSURE_SUCCESS(rv, rv);
aEvent->mReply.mRect = LayoutDeviceIntRect::FromUnknownRect(
rect.ToOutsidePixels(mPresContext->AppUnitsPerDevPixel()));
// If the caret rect is empty, let's make it non-empty rect.
--- a/dom/events/EventStateManager.cpp
+++ b/dom/events/EventStateManager.cpp
@@ -2508,18 +2508,18 @@ EventStateManager::GetScrollAmount(nsPre
return aPresContext->GetVisibleArea().Size();
}
// If there is no scrollable frame, we should use root frame's information.
nsIFrame* rootFrame = aPresContext->PresShell()->GetRootFrame();
if (!rootFrame) {
return nsSize(0, 0);
}
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetInflatedFontMetricsForFrame(rootFrame, getter_AddRefs(fm));
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetInflatedFontMetricsForFrame(rootFrame);
NS_ENSURE_TRUE(fm, nsSize(0, 0));
return nsSize(fm->AveCharWidth(), fm->MaxHeight());
}
void
EventStateManager::DoScrollText(nsIScrollableFrame* aScrollableFrame,
WidgetWheelEvent* aEvent)
{
--- a/dom/svg/SVGContentUtils.cpp
+++ b/dom/svg/SVGContentUtils.cpp
@@ -335,19 +335,18 @@ SVGContentUtils::GetFontXHeight(nsIFrame
float
SVGContentUtils::GetFontXHeight(nsStyleContext *aStyleContext)
{
MOZ_ASSERT(aStyleContext, "NULL style context in GetFontXHeight");
nsPresContext *presContext = aStyleContext->PresContext();
MOZ_ASSERT(presContext, "NULL pres context in GetFontXHeight");
- RefPtr<nsFontMetrics> fontMetrics;
- nsLayoutUtils::GetFontMetricsForStyleContext(aStyleContext,
- getter_AddRefs(fontMetrics));
+ RefPtr<nsFontMetrics> fontMetrics =
+ nsLayoutUtils::GetFontMetricsForStyleContext(aStyleContext);
if (!fontMetrics) {
// ReportToConsole
NS_WARNING("no FontMetrics in GetFontXHeight()");
return 1.0f;
}
nscoord xHeight = fontMetrics->XHeight();
--- a/gfx/src/nsDeviceContext.cpp
+++ b/gfx/src/nsDeviceContext.cpp
@@ -59,19 +59,18 @@ public:
nsFontCache() { MOZ_COUNT_CTOR(nsFontCache); }
NS_DECL_ISUPPORTS
NS_DECL_NSIOBSERVER
void Init(nsDeviceContext* aContext);
void Destroy();
- nsresult GetMetricsFor(const nsFont& aFont,
- const nsFontMetrics::Params& aParams,
- nsFontMetrics*& aMetrics);
+ already_AddRefed<nsFontMetrics> GetMetricsFor(
+ const nsFont& aFont, const nsFontMetrics::Params& aParams);
void FontMetricsDeleted(const nsFontMetrics* aFontMetrics);
void Compact();
void Flush();
protected:
~nsFontCache() { MOZ_COUNT_DTOR(nsFontCache); }
@@ -117,58 +116,52 @@ nsFontCache::Destroy()
NS_IMETHODIMP
nsFontCache::Observe(nsISupports*, const char* aTopic, const char16_t*)
{
if (!nsCRT::strcmp(aTopic, "memory-pressure"))
Compact();
return NS_OK;
}
-nsresult
+already_AddRefed<nsFontMetrics>
nsFontCache::GetMetricsFor(const nsFont& aFont,
- const nsFontMetrics::Params& aParams,
- nsFontMetrics*& aMetrics)
+ const nsFontMetrics::Params& aParams)
{
nsIAtom* language = aParams.language ? aParams.language
: mLocaleLanguage.get();
// First check our cache
// start from the end, which is where we put the most-recent-used element
- nsFontMetrics* fm;
int32_t n = mFontMetrics.Length() - 1;
for (int32_t i = n; i >= 0; --i) {
- fm = mFontMetrics[i];
+ nsFontMetrics* fm = mFontMetrics[i];
if (fm->Font().Equals(aFont) &&
fm->GetUserFontSet() == aParams.userFontSet &&
fm->Language() == language &&
fm->Orientation() == aParams.orientation) {
if (i != n) {
// promote it to the end of the cache
mFontMetrics.RemoveElementAt(i);
mFontMetrics.AppendElement(fm);
}
fm->GetThebesFontGroup()->UpdateUserFonts();
- NS_ADDREF(aMetrics = fm);
- return NS_OK;
+ return do_AddRef(Move(fm));
}
}
// It's not in the cache. Get font metrics and then cache them.
nsFontMetrics::Params params = aParams;
params.language = language;
- fm = new nsFontMetrics(aFont, params, mContext);
- NS_ADDREF(fm);
+ RefPtr<nsFontMetrics> fm = new nsFontMetrics(aFont, params, mContext);
// the mFontMetrics list has the "head" at the end, because append
// is cheaper than insert
- mFontMetrics.AppendElement(fm);
- aMetrics = fm;
- NS_ADDREF(aMetrics);
- return NS_OK;
+ mFontMetrics.AppendElement(do_AddRef(fm.get()).take());
+ return fm.forget();
}
void
nsFontCache::FontMetricsDeleted(const nsFontMetrics* aFontMetrics)
{
mFontMetrics.RemoveElement(aFontMetrics);
}
@@ -222,28 +215,27 @@ nsDeviceContext::nsDeviceContext()
nsDeviceContext::~nsDeviceContext()
{
if (mFontCache) {
mFontCache->Destroy();
NS_RELEASE(mFontCache);
}
}
-nsresult
+already_AddRefed<nsFontMetrics>
nsDeviceContext::GetMetricsFor(const nsFont& aFont,
- const nsFontMetrics::Params& aParams,
- nsFontMetrics*& aMetrics)
+ const nsFontMetrics::Params& aParams)
{
if (!mFontCache) {
mFontCache = new nsFontCache();
NS_ADDREF(mFontCache);
mFontCache->Init(this);
}
- return mFontCache->GetMetricsFor(aFont, aParams, aMetrics);
+ return mFontCache->GetMetricsFor(aFont, aParams);
}
nsresult
nsDeviceContext::FlushFontCache(void)
{
if (mFontCache)
mFontCache->Flush();
return NS_OK;
--- a/gfx/src/nsDeviceContext.h
+++ b/gfx/src/nsDeviceContext.h
@@ -108,22 +108,19 @@ public:
*/
int32_t AppUnitsPerDevPixelAtUnitFullZoom() const
{ return mAppUnitsPerDevPixelAtUnitFullZoom; }
/**
* Get the nsFontMetrics that describe the properties of
* an nsFont.
* @param aFont font description to obtain metrics for
- * @param aMetrics out parameter for font metrics
- * @return error status
*/
- nsresult GetMetricsFor(const nsFont& aFont,
- const nsFontMetrics::Params& aParams,
- nsFontMetrics*& aMetrics);
+ already_AddRefed<nsFontMetrics> GetMetricsFor(
+ const nsFont& aFont, const nsFontMetrics::Params& aParams);
/**
* Notification when a font metrics instance created for this device is
* about to be deleted
*/
nsresult FontMetricsDeleted(const nsFontMetrics* aFontMetrics);
/**
--- a/layout/base/PositionedEventTargeting.cpp
+++ b/layout/base/PositionedEventTargeting.cpp
@@ -520,18 +520,18 @@ IsElementClickableAndReadable(nsIFrame*
// with a very small size (1px) to handle the selection of text.
// With such libraries, the font size of the text elements is not relevant to detect small elements.
testFontSize = true;
}
}
if (testFontSize) {
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetInflatedFontMetricsForFrame(aFrame, getter_AddRefs(fm));
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetInflatedFontMetricsForFrame(aFrame);
if (fm && fm->EmHeight() > 0 && // See bug 1171731
(pc->AppUnitsToGfxUnits(fm->EmHeight()) * cumulativeResolution) < limitReadableSize) {
return false;
}
}
return true;
}
--- a/layout/base/nsCaret.cpp
+++ b/layout/base/nsCaret.cpp
@@ -316,18 +316,18 @@ nsCaret::GetGeometryForFrame(nsIFrame* a
nsIFrame* frame = aFrame->GetContentInsertionFrame();
if (!frame) {
frame = aFrame;
}
NS_ASSERTION(!(frame->GetStateBits() & NS_FRAME_IN_REFLOW),
"We should not be in the middle of reflow");
nscoord baseline = frame->GetCaretBaseline();
nscoord ascent = 0, descent = 0;
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetInflatedFontMetricsForFrame(aFrame, getter_AddRefs(fm));
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetInflatedFontMetricsForFrame(aFrame);
NS_ASSERTION(fm, "We should be able to get the font metrics");
if (fm) {
ascent = fm->MaxAscent();
descent = fm->MaxDescent();
}
nscoord height = ascent + descent;
WritingMode wm = aFrame->GetWritingMode();
bool vertical = wm.IsVertical();
--- a/layout/base/nsLayoutUtils.cpp
+++ b/layout/base/nsLayoutUtils.cpp
@@ -4053,29 +4053,24 @@ nsLayoutUtils::ComputeObjectDestRect(con
*aAnchorPoint = imageTopLeftPt;
} else {
*aAnchorPoint = imageAnchorPt;
}
}
return nsRect(imageTopLeftPt, concreteObjectSize);
}
-nsresult
-nsLayoutUtils::GetFontMetricsForFrame(const nsIFrame* aFrame,
- nsFontMetrics** aFontMetrics,
- float aInflation)
-{
- return nsLayoutUtils::GetFontMetricsForStyleContext(aFrame->StyleContext(),
- aFontMetrics,
- aInflation);
-}
-
-nsresult
+already_AddRefed<nsFontMetrics>
+nsLayoutUtils::GetFontMetricsForFrame(const nsIFrame* aFrame, float aInflation)
+{
+ return GetFontMetricsForStyleContext(aFrame->StyleContext(), aInflation);
+}
+
+already_AddRefed<nsFontMetrics>
nsLayoutUtils::GetFontMetricsForStyleContext(nsStyleContext* aStyleContext,
- nsFontMetrics** aFontMetrics,
float aInflation)
{
nsPresContext* pc = aStyleContext->PresContext();
WritingMode wm(aStyleContext);
const nsStyleFont* styleFont = aStyleContext->StyleFont();
nsFontMetrics::Params params;
params.language = styleFont->mLanguage;
@@ -4088,23 +4083,22 @@ nsLayoutUtils::GetFontMetricsForStyleCon
params.userFontSet = pc->GetUserFontSet();
params.textPerf = pc->GetTextPerfMetrics();
// When aInflation is 1.0, avoid making a local copy of the nsFont.
// This also avoids running font.size through floats when it is large,
// which would be lossy. Fortunately, in such cases, aInflation is
// guaranteed to be 1.0f.
if (aInflation == 1.0f) {
- return pc->DeviceContext()->GetMetricsFor(styleFont->mFont, params,
- *aFontMetrics);
+ return pc->DeviceContext()->GetMetricsFor(styleFont->mFont, params);
}
nsFont font = styleFont->mFont;
font.size = NSToCoordRound(font.size * aInflation);
- return pc->DeviceContext()->GetMetricsFor(font, params, *aFontMetrics);
+ return pc->DeviceContext()->GetMetricsFor(font, params);
}
nsIFrame*
nsLayoutUtils::FindChildContainingDescendant(nsIFrame* aParent, nsIFrame* aDescendantFrame)
{
nsIFrame* result = aDescendantFrame;
while (result) {
@@ -8527,18 +8521,18 @@ nsLayoutUtils::IsOutlineStyleAutoEnabled
/* static */ void
nsLayoutUtils::SetBSizeFromFontMetrics(const nsIFrame* aFrame,
nsHTMLReflowMetrics& aMetrics,
const LogicalMargin& aFramePadding,
WritingMode aLineWM,
WritingMode aFrameWM)
{
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetInflatedFontMetricsForFrame(aFrame, getter_AddRefs(fm));
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetInflatedFontMetricsForFrame(aFrame);
if (fm) {
// Compute final height of the frame.
//
// Do things the standard css2 way -- though it's hard to find it
// in the css2 spec! It's actually found in the css1 spec section
// 4.4 (you will have to read between the lines to really see
// it).
--- a/layout/base/nsLayoutUtils.h
+++ b/layout/base/nsLayoutUtils.h
@@ -1217,57 +1217,46 @@ public:
const IntrinsicSize& aIntrinsicSize,
const nsSize& aIntrinsicRatio,
const nsStylePosition* aStylePos,
nsPoint* aAnchorPoint = nullptr);
/**
* Get the font metrics corresponding to the frame's style data.
* @param aFrame the frame
- * @param aFontMetrics the font metrics result
* @param aSizeInflation number to multiply font size by
- * @return success or failure code
*/
- static nsresult GetFontMetricsForFrame(const nsIFrame* aFrame,
- nsFontMetrics** aFontMetrics,
- float aSizeInflation);
+ static already_AddRefed<nsFontMetrics> GetFontMetricsForFrame(
+ const nsIFrame* aFrame, float aSizeInflation);
- static nsresult GetInflatedFontMetricsForFrame(const nsIFrame* aFrame,
- nsFontMetrics** aFontMetrics)
+ static already_AddRefed<nsFontMetrics>
+ GetInflatedFontMetricsForFrame(const nsIFrame* aFrame)
{
- return GetFontMetricsForFrame(aFrame, aFontMetrics,
- FontSizeInflationFor(aFrame));
+ return GetFontMetricsForFrame(aFrame, FontSizeInflationFor(aFrame));
}
/**
* Get the font metrics corresponding to the given style data.
* @param aStyleContext the style data
- * @param aFontMetrics the font metrics result
* @param aSizeInflation number to multiply font size by
- * @return success or failure code
*/
- static nsresult GetFontMetricsForStyleContext(nsStyleContext* aStyleContext,
- nsFontMetrics** aFontMetrics,
- float aSizeInflation = 1.0f);
+ static already_AddRefed<nsFontMetrics> GetFontMetricsForStyleContext(
+ nsStyleContext* aStyleContext, float aSizeInflation = 1.0f);
/**
* Get the font metrics of emphasis marks corresponding to the given
* style data. The result is same as GetFontMetricsForStyleContext
* except that the font size is scaled down to 50%.
* @param aStyleContext the style data
- * @param aFontMetrics the font metrics result
* @param aInflation number to multiple font size by
- * @return success or failure code
*/
- static nsresult GetFontMetricsOfEmphasisMarks(nsStyleContext* aStyleContext,
- nsFontMetrics** aFontMetrics,
- float aInflation)
+ static already_AddRefed<nsFontMetrics> GetFontMetricsOfEmphasisMarks(
+ nsStyleContext* aStyleContext, float aInflation)
{
- return GetFontMetricsForStyleContext(aStyleContext, aFontMetrics,
- aInflation * 0.5f);
+ return GetFontMetricsForStyleContext(aStyleContext, aInflation * 0.5f);
}
/**
* Find the immediate child of aParent whose frame subtree contains
* aDescendantFrame. Returns null if aDescendantFrame is not a descendant
* of aParent.
*/
static nsIFrame* FindChildContainingDescendant(nsIFrame* aParent, nsIFrame* aDescendantFrame);
--- a/layout/base/nsPresShell.cpp
+++ b/layout/base/nsPresShell.cpp
@@ -10339,19 +10339,18 @@ void ReflowCountMgr::PaintCount(const ch
aRenderingContext->ThebesContext()->CurrentMatrix().Translate(devPixelOffset));
// We don't care about the document language or user fonts here;
// just get a default Latin font.
nsFont font(eFamily_serif, nsPresContext::CSSPixelsToAppUnits(11));
nsFontMetrics::Params params;
params.language = nsGkAtoms::x_western;
params.textPerf = aPresContext->GetTextPerfMetrics();
- RefPtr<nsFontMetrics> fm;
- aPresContext->DeviceContext()->
- GetMetricsFor(font, params, *getter_AddRefs(fm));
+ RefPtr<nsFontMetrics> fm =
+ aPresContext->DeviceContext()->GetMetricsFor(font, params);
char buf[16];
int len = snprintf_literal(buf, "%d", counter->mCount);
nscoord x = 0, y = fm->MaxAscent();
nscoord width, height = fm->MaxHeight();
fm->SetTextRunRTL(false);
width = fm->GetWidth(buf, len, drawTarget);
--- a/layout/forms/nsListControlFrame.cpp
+++ b/layout/forms/nsListControlFrame.cpp
@@ -1546,26 +1546,19 @@ nsListControlFrame::IsLeftButton(nsIDOME
}
}
return false;
}
nscoord
nsListControlFrame::CalcFallbackRowBSize(float aFontSizeInflation)
{
- nscoord rowBSize = 0;
-
- RefPtr<nsFontMetrics> fontMet;
- nsLayoutUtils::GetFontMetricsForFrame(this, getter_AddRefs(fontMet),
- aFontSizeInflation);
- if (fontMet) {
- rowBSize = fontMet->MaxHeight();
- }
-
- return rowBSize;
+ RefPtr<nsFontMetrics> fontMet =
+ nsLayoutUtils::GetFontMetricsForFrame(this, aFontSizeInflation);
+ return fontMet->MaxHeight();
}
nscoord
nsListControlFrame::CalcIntrinsicBSize(nscoord aBSizeOfARow,
int32_t aNumberOfOptions)
{
NS_PRECONDITION(!IsInDropDownMode(),
"Shouldn't be in dropdown mode when we call this");
--- a/layout/forms/nsMeterFrame.cpp
+++ b/layout/forms/nsMeterFrame.cpp
@@ -225,20 +225,18 @@ nsMeterFrame::ComputeAutoSize(nsRenderin
WritingMode aWM,
const LogicalSize& aCBSize,
nscoord aAvailableISize,
const LogicalSize& aMargin,
const LogicalSize& aBorder,
const LogicalSize& aPadding,
bool aShrinkWrap)
{
- RefPtr<nsFontMetrics> fontMet;
- NS_ENSURE_SUCCESS(nsLayoutUtils::GetFontMetricsForFrame(this,
- getter_AddRefs(fontMet), 1.0f),
- LogicalSize(aWM));
+ RefPtr<nsFontMetrics> fontMet =
+ nsLayoutUtils::GetFontMetricsForFrame(this, 1.0f);
const WritingMode wm = GetWritingMode();
LogicalSize autoSize(wm);
autoSize.BSize(wm) = autoSize.ISize(wm) = fontMet->Font().size; // 1em
if (ResolvedOrientationIsVertical() == wm.IsVertical()) {
autoSize.ISize(wm) *= 5; // 5em
} else {
@@ -246,19 +244,18 @@ nsMeterFrame::ComputeAutoSize(nsRenderin
}
return autoSize.ConvertTo(aWM, wm);
}
nscoord
nsMeterFrame::GetMinISize(nsRenderingContext *aRenderingContext)
{
- RefPtr<nsFontMetrics> fontMet;
- NS_ENSURE_SUCCESS(
- nsLayoutUtils::GetFontMetricsForFrame(this, getter_AddRefs(fontMet), 1.0f), 0);
+ RefPtr<nsFontMetrics> fontMet =
+ nsLayoutUtils::GetFontMetricsForFrame(this, 1.0f);
nscoord minISize = fontMet->Font().size; // 1em
if (ResolvedOrientationIsVertical() == GetWritingMode().IsVertical()) {
// The orientation is inline
minISize *= 5; // 5em
}
--- a/layout/forms/nsProgressFrame.cpp
+++ b/layout/forms/nsProgressFrame.cpp
@@ -252,19 +252,18 @@ nsProgressFrame::ComputeAutoSize(nsRende
}
return autoSize.ConvertTo(aWM, wm);
}
nscoord
nsProgressFrame::GetMinISize(nsRenderingContext *aRenderingContext)
{
- RefPtr<nsFontMetrics> fontMet;
- NS_ENSURE_SUCCESS(
- nsLayoutUtils::GetFontMetricsForFrame(this, getter_AddRefs(fontMet), 1.0f), 0);
+ RefPtr<nsFontMetrics> fontMet =
+ nsLayoutUtils::GetFontMetricsForFrame(this, 1.0f);
nscoord minISize = fontMet->Font().size; // 1em
if (ResolvedOrientationIsVertical() == GetWritingMode().IsVertical()) {
// The orientation is inline
minISize *= 10; // 10em
}
--- a/layout/forms/nsTextControlFrame.cpp
+++ b/layout/forms/nsTextControlFrame.cpp
@@ -150,21 +150,18 @@ nsTextControlFrame::CalcIntrinsicSize(ns
LogicalSize& aIntrinsicSize,
float aFontSizeInflation)
{
// Get leading and the Average/MaxAdvance char width
nscoord lineHeight = 0;
nscoord charWidth = 0;
nscoord charMaxAdvance = 0;
- RefPtr<nsFontMetrics> fontMet;
- nsresult rv =
- nsLayoutUtils::GetFontMetricsForFrame(this, getter_AddRefs(fontMet),
- aFontSizeInflation);
- NS_ENSURE_SUCCESS(rv, rv);
+ RefPtr<nsFontMetrics> fontMet =
+ nsLayoutUtils::GetFontMetricsForFrame(this, aFontSizeInflation);
lineHeight =
nsHTMLReflowState::CalcLineHeight(GetContent(), StyleContext(),
NS_AUTOHEIGHT, aFontSizeInflation);
charWidth = fontMet->AveCharWidth();
charMaxAdvance = fontMet->MaxAdvance();
// Set the width equal to the width in characters
@@ -518,19 +515,18 @@ nsTextControlFrame::Reflow(nsPresContext
// computation of the ascent wrt the input height
nscoord lineHeight = aReflowState.ComputedBSize();
float inflation = nsLayoutUtils::FontSizeInflationFor(this);
if (!IsSingleLineTextControl()) {
lineHeight = nsHTMLReflowState::CalcLineHeight(GetContent(), StyleContext(),
NS_AUTOHEIGHT, inflation);
}
- RefPtr<nsFontMetrics> fontMet;
- nsLayoutUtils::GetFontMetricsForFrame(this, getter_AddRefs(fontMet),
- inflation);
+ RefPtr<nsFontMetrics> fontMet =
+ nsLayoutUtils::GetFontMetricsForFrame(this, inflation);
// now adjust for our borders and padding
aDesiredSize.SetBlockStartAscent(
nsLayoutUtils::GetCenteredFontBaseline(fontMet, lineHeight,
wm.IsLineInverted()) +
aReflowState.ComputedLogicalBorderPadding().BStart(wm));
// overflow handling
aDesiredSize.SetOverflowAreasToDesiredBounds();
--- a/layout/generic/MathMLTextRunFactory.cpp
+++ b/layout/generic/MathMLTextRunFactory.cpp
@@ -741,21 +741,19 @@ MathMLTextRunFactory::RebuildTextRun(nsT
if (length) {
font.size = NSToCoordRound(font.size * mFontInflation);
nsPresContext* pc = styles[0]->mPresContext;
nsFontMetrics::Params params;
params.language = styles[0]->mLanguage;
params.explicitLanguage = styles[0]->mExplicitLanguage;
params.userFontSet = pc->GetUserFontSet();
params.textPerf = pc->GetTextPerfMetrics();
- RefPtr<nsFontMetrics> metrics;
- pc->DeviceContext()->GetMetricsFor(font, params, *getter_AddRefs(metrics));
- if (metrics) {
- newFontGroup = metrics->GetThebesFontGroup();
- }
+ RefPtr<nsFontMetrics> metrics =
+ pc->DeviceContext()->GetMetricsFor(font, params);
+ newFontGroup = metrics->GetThebesFontGroup();
}
if (!newFontGroup) {
// If we can't get a new font group, fall back to the old one. Rendering
// will be incorrect, but not significantly so.
newFontGroup = fontGroup;
}
--- a/layout/generic/TextOverflow.cpp
+++ b/layout/generic/TextOverflow.cpp
@@ -44,18 +44,18 @@ public:
}
private:
nsIFrame* mFrame;
};
static gfxTextRun*
GetEllipsisTextRun(nsIFrame* aFrame)
{
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetInflatedFontMetricsForFrame(aFrame, getter_AddRefs(fm));
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetInflatedFontMetricsForFrame(aFrame);
LazyReferenceRenderingDrawTargetGetterFromFrame lazyRefDrawTargetGetter(aFrame);
return fm->GetThebesFontGroup()->GetEllipsisTextRun(
aFrame->PresContext()->AppUnitsPerDevPixel(),
nsLayoutUtils::GetTextRunOrientFlagsForStyle(aFrame->StyleContext()),
lazyRefDrawTargetGetter);
}
static nsIFrame*
@@ -250,18 +250,18 @@ nsDisplayTextOverflowMarker::PaintTextTo
if (textRun) {
NS_ASSERTION(!textRun->IsRightToLeft(),
"Ellipsis textruns should always be LTR!");
gfxPoint gfxPt(pt.x, pt.y);
textRun->Draw(gfxTextRun::Range(textRun), gfxPt,
gfxTextRun::DrawParams(aCtx->ThebesContext()));
}
} else {
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetInflatedFontMetricsForFrame(mFrame, getter_AddRefs(fm));
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetInflatedFontMetricsForFrame(mFrame);
nsLayoutUtils::DrawString(mFrame, *fm, aCtx, mStyle->mString.get(),
mStyle->mString.Length(), pt);
}
}
TextOverflow::TextOverflow(nsDisplayListBuilder* aBuilder,
nsIFrame* aBlockFrame)
: mContentArea(aBlockFrame->GetWritingMode(),
@@ -803,18 +803,18 @@ TextOverflow::Marker::SetupString(nsIFra
if (textRun) {
mISize = textRun->GetAdvanceWidth();
} else {
mISize = 0;
}
} else {
nsRenderingContext rc(
aFrame->PresContext()->PresShell()->CreateReferenceRenderingContext());
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetInflatedFontMetricsForFrame(aFrame, getter_AddRefs(fm));
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetInflatedFontMetricsForFrame(aFrame);
mISize = nsLayoutUtils::AppUnitWidthOfStringBidi(mStyle->mString, aFrame,
*fm, rc);
}
mIntrinsicISize = mISize;
mInitialized = true;
}
} // namespace css
--- a/layout/generic/nsBRFrame.cpp
+++ b/layout/generic/nsBRFrame.cpp
@@ -116,18 +116,18 @@ BRFrame::Reflow(nsPresContext* aPresCont
// line-height rather than the font size because the
// quirks-mode fix that doesn't apply the block's min
// line-height makes this necessary to make BR cause a line
// of the full line-height
// We also do this in strict mode because BR should act like a
// normal inline frame. That line-height is used is important
// here for cases where the line-height is less than 1.
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetInflatedFontMetricsForFrame(this, getter_AddRefs(fm));
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetInflatedFontMetricsForFrame(this);
if (fm) {
nscoord logicalHeight = aReflowState.CalcLineHeight();
finalSize.BSize(wm) = logicalHeight;
aMetrics.SetBlockStartAscent(nsLayoutUtils::GetCenteredFontBaseline(
fm, logicalHeight, wm.IsLineInverted()));
}
else {
aMetrics.SetBlockStartAscent(aMetrics.BSize(wm) = 0);
--- a/layout/generic/nsBlockFrame.cpp
+++ b/layout/generic/nsBlockFrame.cpp
@@ -500,19 +500,19 @@ nsBlockFrame::GetCaretBaseline() const
if (!mLines.empty()) {
const_line_iterator line = begin_lines();
const nsLineBox* firstLine = line;
if (firstLine->GetChildCount()) {
return bp.top + firstLine->mFirstChild->GetCaretBaseline();
}
}
- RefPtr<nsFontMetrics> fm;
float inflation = nsLayoutUtils::FontSizeInflationFor(this);
- nsLayoutUtils::GetFontMetricsForFrame(this, getter_AddRefs(fm), inflation);
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetFontMetricsForFrame(this, inflation);
nscoord lineHeight =
nsHTMLReflowState::CalcLineHeight(GetContent(), StyleContext(),
contentRect.height, inflation);
const WritingMode wm = GetWritingMode();
return nsLayoutUtils::GetCenteredFontBaseline(fm, lineHeight,
wm.IsLineInverted()) + bp.top;
}
@@ -2620,18 +2620,18 @@ nsBlockFrame::ReflowDirtyLines(nsBlockRe
WritingMode wm = aState.mReflowState.GetWritingMode();
if (nsLayoutUtils::GetFirstLineBaseline(wm, bullet, &ascent)) {
metrics.SetBlockStartAscent(ascent);
} else {
metrics.SetBlockStartAscent(metrics.BSize(wm));
}
}
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetInflatedFontMetricsForFrame(this, getter_AddRefs(fm));
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetInflatedFontMetricsForFrame(this);
nscoord minAscent =
nsLayoutUtils::GetCenteredFontBaseline(fm, aState.mMinLineHeight,
wm.IsLineInverted());
nscoord minDescent = aState.mMinLineHeight - minAscent;
aState.mBCoord += std::max(minAscent, metrics.BlockStartAscent()) +
std::max(minDescent, metrics.BSize(wm) -
--- a/layout/generic/nsBulletFrame.cpp
+++ b/layout/generic/nsBulletFrame.cpp
@@ -299,17 +299,16 @@ nsBulletFrame::PaintBullet(nsRenderingCo
nsLayoutUtils::DrawSingleImage(*aRenderingContext.ThebesContext(),
PresContext(),
imageCon, nsLayoutUtils::GetGraphicsFilterForFrame(this),
dest + aPt, aDirtyRect, nullptr, aFlags);
}
}
}
- RefPtr<nsFontMetrics> fm;
ColorPattern color(ToDeviceColor(
nsLayoutUtils::GetColor(this, eCSSProperty_color)));
DrawTarget* drawTarget = aRenderingContext.GetDrawTarget();
int32_t appUnitsPerDevPixel = PresContext()->AppUnitsPerDevPixel();
switch (listStyleType->GetStyle()) {
case NS_STYLE_LIST_STYLE_NONE:
@@ -407,18 +406,18 @@ nsBulletFrame::PaintBullet(nsRenderingCo
}
break;
default:
{
aRenderingContext.ThebesContext()->SetColor(
Color::FromABGR(nsLayoutUtils::GetColor(this, eCSSProperty_color)));
- nsLayoutUtils::GetFontMetricsForFrame(this, getter_AddRefs(fm),
- GetFontSizeInflation());
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetFontMetricsForFrame(this, GetFontSizeInflation());
nsAutoString text;
GetListItemText(text);
WritingMode wm = GetWritingMode();
nscoord ascent = wm.IsLineInverted()
? fm->MaxDescent() : fm->MaxAscent();
aPt.MoveBy(padding.left, padding.top);
gfxContext *ctx = aRenderingContext.ThebesContext();
if (wm.IsVertical()) {
@@ -530,19 +529,18 @@ nsBulletFrame::GetDesiredSize(nsPresCont
{
// Reset our padding. If we need it, we'll set it below.
WritingMode wm = GetWritingMode();
aPadding->SizeTo(wm, 0, 0, 0, 0);
LogicalSize finalSize(wm);
const nsStyleList* myList = StyleList();
nscoord ascent;
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetFontMetricsForFrame(this, getter_AddRefs(fm),
- aFontSizeInflation);
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetFontMetricsForFrame(this, aFontSizeInflation);
RemoveStateBits(BULLET_FRAME_IMAGE_LOADING);
if (myList->GetListStyleImage() && mImageRequest) {
uint32_t status;
mImageRequest->GetImageStatus(&status);
if (status & imgIRequest::STATUS_SIZE_AVAILABLE &&
!(status & imgIRequest::STATUS_ERROR)) {
@@ -887,19 +885,18 @@ nsBulletFrame::GetImage() const
nscoord
nsBulletFrame::GetLogicalBaseline(WritingMode aWritingMode) const
{
nscoord ascent = 0, baselinePadding;
if (GetStateBits() & BULLET_FRAME_IMAGE_LOADING) {
ascent = BSize(aWritingMode);
} else {
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetFontMetricsForFrame(this, getter_AddRefs(fm),
- GetFontSizeInflation());
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetFontMetricsForFrame(this, GetFontSizeInflation());
CounterStyle* listStyleType = StyleList()->GetCounterStyle();
switch (listStyleType->GetStyle()) {
case NS_STYLE_LIST_STYLE_NONE:
break;
case NS_STYLE_LIST_STYLE_DISC:
case NS_STYLE_LIST_STYLE_CIRCLE:
case NS_STYLE_LIST_STYLE_SQUARE:
--- a/layout/generic/nsGfxScrollFrame.cpp
+++ b/layout/generic/nsGfxScrollFrame.cpp
@@ -3899,18 +3899,18 @@ ScrollFrameHelper::ScrollSnap(const nsPo
snapDestination)) {
ScrollTo(snapDestination, aMode);
}
}
nsSize
ScrollFrameHelper::GetLineScrollAmount() const
{
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetInflatedFontMetricsForFrame(mOuter, getter_AddRefs(fm));
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetInflatedFontMetricsForFrame(mOuter);
NS_ASSERTION(fm, "FontMetrics is null, assuming fontHeight == 1 appunit");
static nscoord sMinLineScrollAmountInPixels = -1;
if (sMinLineScrollAmountInPixels < 0) {
Preferences::AddIntVarCache(&sMinLineScrollAmountInPixels,
"mousewheel.min_line_scroll_amount", 1);
}
int32_t appUnitsPerDevPixel = mOuter->PresContext()->AppUnitsPerDevPixel();
nscoord minScrollAmountInAppUnits =
--- a/layout/generic/nsHTMLReflowState.cpp
+++ b/layout/generic/nsHTMLReflowState.cpp
@@ -2688,20 +2688,18 @@ ComputeLineHeight(nsStyleContext* aStyle
if (lhCoord.GetUnit() == eStyleUnit_Enumerated) {
NS_ASSERTION(lhCoord.GetIntValue() == NS_STYLE_LINE_HEIGHT_BLOCK_HEIGHT,
"bad line-height value");
if (aBlockBSize != NS_AUTOHEIGHT) {
return aBlockBSize;
}
}
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetFontMetricsForStyleContext(aStyleContext,
- getter_AddRefs(fm),
- aFontSizeInflation);
+ RefPtr<nsFontMetrics> fm = nsLayoutUtils::
+ GetFontMetricsForStyleContext(aStyleContext, aFontSizeInflation);
return GetNormalLineHeight(fm);
}
nscoord
nsHTMLReflowState::CalcLineHeight() const
{
nscoord blockBSize =
nsLayoutUtils::IsNonWrapperBlock(frame) ? ComputedBSize() :
--- a/layout/generic/nsImageFrame.cpp
+++ b/layout/generic/nsImageFrame.cpp
@@ -1125,18 +1125,18 @@ void
nsImageFrame::DisplayAltText(nsPresContext* aPresContext,
nsRenderingContext& aRenderingContext,
const nsString& aAltText,
const nsRect& aRect)
{
// Set font and color
aRenderingContext.ThebesContext()->
SetColor(Color::FromABGR(StyleColor()->mColor));
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetInflatedFontMetricsForFrame(this, getter_AddRefs(fm));
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetInflatedFontMetricsForFrame(this);
// Format the text to display within the formatting rect
nscoord maxAscent = fm->MaxAscent();
nscoord maxDescent = fm->MaxDescent();
nscoord lineHeight = fm->MaxHeight(); // line-relative, so an x-coordinate
// length if writing mode is vertical
--- a/layout/generic/nsLineLayout.cpp
+++ b/layout/generic/nsLineLayout.cpp
@@ -1675,19 +1675,18 @@ nsLineLayout::PlaceTopBottomFrames(PerSp
PlaceTopBottomFrames(span, fromStart, aLineBSize);
}
}
}
static nscoord
GetBSizeOfEmphasisMarks(nsIFrame* aSpanFrame, float aInflation)
{
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetFontMetricsOfEmphasisMarks(
- aSpanFrame->StyleContext(), getter_AddRefs(fm), aInflation);
+ RefPtr<nsFontMetrics> fm = nsLayoutUtils::
+ GetFontMetricsOfEmphasisMarks(aSpanFrame->StyleContext(), aInflation);
return fm->MaxHeight();
}
void
nsLineLayout::AdjustLeadings(nsIFrame* spanFrame, PerSpanData* psd,
const nsStyleText* aStyleText, float aInflation,
bool* aZeroEffectiveSpanBox)
{
@@ -1769,21 +1768,20 @@ GetInflationForBlockDirAlignment(nsIFram
void
nsLineLayout::VerticalAlignFrames(PerSpanData* psd)
{
// Get parent frame info
PerFrameData* spanFramePFD = psd->mFrame;
nsIFrame* spanFrame = spanFramePFD->mFrame;
// Get the parent frame's font for all of the frames in this span
- RefPtr<nsFontMetrics> fm;
float inflation =
GetInflationForBlockDirAlignment(spanFrame, mInflationMinFontSize);
- nsLayoutUtils::GetFontMetricsForFrame(spanFrame, getter_AddRefs(fm),
- inflation);
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetFontMetricsForFrame(spanFrame, inflation);
bool preMode = mStyleText->WhiteSpaceIsSignificant();
// See if the span is an empty continuation. It's an empty continuation iff:
// - it has a prev-in-flow
// - it has no next in flow
// - it's zero sized
WritingMode lineWM = mRootSpan->mWritingMode;
--- a/layout/generic/nsPageFrame.cpp
+++ b/layout/generic/nsPageFrame.cpp
@@ -628,19 +628,18 @@ nsPageFrame::PaintHeaderFooter(nsRenderi
DrawTargetAutoDisableSubpixelAntialiasing
disable(aRenderingContext.GetDrawTarget(), aDisableSubpixelAA);
// Get the FontMetrics to determine width.height of strings
nsFontMetrics::Params params;
params.userFontSet = pc->GetUserFontSet();
params.textPerf = pc->GetTextPerfMetrics();
- RefPtr<nsFontMetrics> fontMet;
- pc->DeviceContext()->GetMetricsFor(mPD->mHeadFootFont, params,
- *getter_AddRefs(fontMet));
+ RefPtr<nsFontMetrics> fontMet =
+ pc->DeviceContext()->GetMetricsFor(mPD->mHeadFootFont, params);
nscoord ascent = 0;
nscoord visibleHeight = 0;
if (fontMet) {
visibleHeight = fontMet->MaxHeight();
ascent = fontMet->MaxAscent();
}
--- a/layout/generic/nsTextFrame.cpp
+++ b/layout/generic/nsTextFrame.cpp
@@ -1809,22 +1809,18 @@ BuildTextRunsScanner::GetNextBreakBefore
static gfxFontGroup*
GetFontGroupForFrame(nsIFrame* aFrame, float aFontSizeInflation,
nsFontMetrics** aOutFontMetrics = nullptr)
{
if (aOutFontMetrics)
*aOutFontMetrics = nullptr;
- RefPtr<nsFontMetrics> metrics;
- nsLayoutUtils::GetFontMetricsForFrame(aFrame, getter_AddRefs(metrics),
- aFontSizeInflation);
-
- if (!metrics)
- return nullptr;
+ RefPtr<nsFontMetrics> metrics =
+ nsLayoutUtils::GetFontMetricsForFrame(aFrame, aFontSizeInflation);
if (aOutFontMetrics) {
*aOutFontMetrics = metrics;
NS_ADDREF(*aOutFontMetrics);
}
// XXX this is a bit bogus, we're releasing 'metrics' so the
// returned font-group might actually be torn down, although because
// of the way the device context caches font metrics, this seems to
@@ -5163,19 +5159,18 @@ nsRect
nsTextFrame::UpdateTextEmphasis(WritingMode aWM, PropertyProvider& aProvider)
{
const nsStyleText* styleText = StyleText();
if (!styleText->HasTextEmphasis()) {
Properties().Delete(EmphasisMarkProperty());
return nsRect();
}
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetFontMetricsOfEmphasisMarks(
- StyleContext(), getter_AddRefs(fm), GetFontSizeInflation());
+ RefPtr<nsFontMetrics> fm = nsLayoutUtils::
+ GetFontMetricsOfEmphasisMarks(StyleContext(), GetFontSizeInflation());
EmphasisMarkInfo* info = new EmphasisMarkInfo;
info->textRun =
GenerateTextRunForEmphasisMarks(this, fm, aWM, styleText);
info->advance = info->textRun->GetAdvanceWidth();
// Calculate the baseline offset
LogicalSide side = styleText->TextEmphasisSide(aWM);
nsFontMetrics* baseFontMetrics = aProvider.GetFontMetrics();
@@ -6941,19 +6936,18 @@ bool
nsTextFrame::CombineSelectionUnderlineRect(nsPresContext* aPresContext,
nsRect& aRect)
{
if (aRect.IsEmpty())
return false;
nsRect givenRect = aRect;
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetFontMetricsForFrame(this, getter_AddRefs(fm),
- GetFontSizeInflation());
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetFontMetricsForFrame(this, GetFontSizeInflation());
gfxFontGroup* fontGroup = fm->GetThebesFontGroup();
gfxFont* firstFont = fontGroup->GetFirstValidFont();
WritingMode wm = GetWritingMode();
bool verticalRun = wm.IsVertical();
bool useVerticalMetrics = verticalRun && !wm.IsSideways();
const gfxFont::Metrics& metrics =
firstFont->GetMetrics(useVerticalMetrics ? gfxFont::eVertical
: gfxFont::eHorizontal);
--- a/layout/mathml/nsMathMLChar.cpp
+++ b/layout/mathml/nsMathMLChar.cpp
@@ -991,19 +991,18 @@ nsMathMLChar::SetFontFamily(nsPresContex
nsFont font = aFont;
font.fontlist = familyList;
const nsStyleFont* styleFont = mStyleContext->StyleFont();
nsFontMetrics::Params params;
params.language = styleFont->mLanguage;
params.explicitLanguage = styleFont->mExplicitLanguage;
params.userFontSet = aPresContext->GetUserFontSet();
params.textPerf = aPresContext->GetTextPerfMetrics();
- RefPtr<nsFontMetrics> fm;
- aPresContext->DeviceContext()->
- GetMetricsFor(font, params, *getter_AddRefs(fm));
+ RefPtr<nsFontMetrics> fm =
+ aPresContext->DeviceContext()->GetMetricsFor(font, params);
// Set the font if it is an unicode table
// or if the same family name has been found
gfxFont *firstFont = fm->GetThebesFontGroup()->GetFirstValidFont();
FontFamilyList firstFontList;
firstFontList.Append(
FontFamilyName(firstFont->GetFontEntry()->FamilyName(), eUnquotedName));
if (aGlyphTable == &gGlyphTableList->mUnicodeTable ||
firstFontList == familyList) {
@@ -1532,19 +1531,18 @@ nsMathMLChar::StretchInternal(nsPresCont
NormalizeDefaultFont(font, aFontSizeInflation);
const nsStyleFont* styleFont = mStyleContext->StyleFont();
nsFontMetrics::Params params;
params.language = styleFont->mLanguage;
params.explicitLanguage = styleFont->mExplicitLanguage;
params.userFontSet = aPresContext->GetUserFontSet();
params.textPerf = aPresContext->GetTextPerfMetrics();
- RefPtr<nsFontMetrics> fm;
- aPresContext->DeviceContext()->
- GetMetricsFor(font, params, *getter_AddRefs(fm));
+ RefPtr<nsFontMetrics> fm =
+ aPresContext->DeviceContext()->GetMetricsFor(font, params);
uint32_t len = uint32_t(mData.Length());
nsAutoPtr<gfxTextRun> textRun;
textRun = fm->GetThebesFontGroup()->
MakeTextRun(static_cast<const char16_t*>(mData.get()), len, aDrawTarget,
aPresContext->AppUnitsPerDevPixel(), 0,
aPresContext->MissingFontRecorder());
aDesiredStretchSize = MeasureTextRun(aDrawTarget, textRun);
mGlyphs[0] = textRun;
--- a/layout/mathml/nsMathMLContainerFrame.cpp
+++ b/layout/mathml/nsMathMLContainerFrame.cpp
@@ -44,18 +44,18 @@ nsMathMLContainerFrame::ReflowError(Draw
nsHTMLReflowMetrics& aDesiredSize)
{
// clear all other flags and record that there is an error with this frame
mEmbellishData.flags = 0;
mPresentationData.flags = NS_MATHML_ERROR;
///////////////
// Set font
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetInflatedFontMetricsForFrame(this, getter_AddRefs(fm));
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetInflatedFontMetricsForFrame(this);
// bounding metrics
nsAutoString errorMsg; errorMsg.AssignLiteral("invalid-markup");
mBoundingMetrics =
nsLayoutUtils::AppUnitBoundsOfString(errorMsg.get(), errorMsg.Length(),
*fm, aDrawTarget);
// reflow metrics
@@ -87,18 +87,18 @@ public:
nsRenderingContext* aCtx) override;
NS_DISPLAY_DECL_NAME("MathMLError", TYPE_MATHML_ERROR)
};
void nsDisplayMathMLError::Paint(nsDisplayListBuilder* aBuilder,
nsRenderingContext* aCtx)
{
// Set color and font ...
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetFontMetricsForFrame(mFrame, getter_AddRefs(fm), 1.0f);
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetFontMetricsForFrame(mFrame, 1.0f);
nsPoint pt = ToReferenceFrame();
int32_t appUnitsPerDevPixel = mFrame->PresContext()->AppUnitsPerDevPixel();
DrawTarget* drawTarget = aCtx->GetDrawTarget();
Rect rect = NSRectToSnappedRect(nsRect(pt, mFrame->GetSize()),
appUnitsPerDevPixel,
*drawTarget);
ColorPattern red(ToDeviceColor(Color(1.f, 0.f, 0.f, 1.f)));
--- a/layout/mathml/nsMathMLFrame.cpp
+++ b/layout/mathml/nsMathMLFrame.cpp
@@ -227,20 +227,18 @@ nsMathMLFrame::CalcLength(nsPresContext*
nsCSSUnit unit = aCSSValue.GetUnit();
if (eCSSUnit_EM == unit) {
const nsStyleFont* font = aStyleContext->StyleFont();
return NSToCoordRound(aCSSValue.GetFloatValue() * (float)font->mFont.size);
}
else if (eCSSUnit_XHeight == unit) {
aPresContext->SetUsesExChUnits(true);
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetFontMetricsForStyleContext(aStyleContext,
- getter_AddRefs(fm),
- aFontSizeInflation);
+ RefPtr<nsFontMetrics> fm = nsLayoutUtils::
+ GetFontMetricsForStyleContext(aStyleContext, aFontSizeInflation);
nscoord xHeight = fm->XHeight();
return NSToCoordRound(aCSSValue.GetFloatValue() * (float)xHeight);
}
// MathML doesn't specify other CSS units such as rem or ch
NS_ERROR("Unsupported unit");
return 0;
}
--- a/layout/mathml/nsMathMLFrame.h
+++ b/layout/mathml/nsMathMLFrame.h
@@ -193,30 +193,28 @@ public:
}
// helper methods for getting sup/subdrop's from a child
static void
GetSubDropFromChild(nsIFrame* aChild,
nscoord& aSubDrop,
float aFontSizeInflation)
{
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetFontMetricsForFrame(aChild, getter_AddRefs(fm),
- aFontSizeInflation);
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetFontMetricsForFrame(aChild, aFontSizeInflation);
GetSubDrop(fm, aSubDrop);
}
static void
GetSupDropFromChild(nsIFrame* aChild,
nscoord& aSupDrop,
float aFontSizeInflation)
{
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetFontMetricsForFrame(aChild, getter_AddRefs(fm),
- aFontSizeInflation);
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetFontMetricsForFrame(aChild, aFontSizeInflation);
GetSupDrop(fm, aSupDrop);
}
static void
GetSkewCorrectionFromChild(nsIFrame* aChild,
nscoord& aSkewCorrection)
{
// default is 0
--- a/layout/mathml/nsMathMLTokenFrame.cpp
+++ b/layout/mathml/nsMathMLTokenFrame.cpp
@@ -168,18 +168,18 @@ nsMathMLTokenFrame::Place(DrawTarget*
for (nsIFrame* childFrame :PrincipalChildList()) {
nsHTMLReflowMetrics childSize(aDesiredSize.GetWritingMode());
GetReflowAndBoundingMetricsFor(childFrame, childSize,
childSize.mBoundingMetrics, nullptr);
// compute and cache the bounding metrics
mBoundingMetrics += childSize.mBoundingMetrics;
}
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetInflatedFontMetricsForFrame(this, getter_AddRefs(fm));
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetInflatedFontMetricsForFrame(this);
nscoord ascent = fm->MaxAscent();
nscoord descent = fm->MaxDescent();
aDesiredSize.mBoundingMetrics = mBoundingMetrics;
aDesiredSize.Width() = mBoundingMetrics.width;
aDesiredSize.SetBlockStartAscent(std::max(mBoundingMetrics.ascent, ascent));
aDesiredSize.Height() = aDesiredSize.BlockStartAscent() +
std::max(mBoundingMetrics.descent, descent);
--- a/layout/mathml/nsMathMLmencloseFrame.cpp
+++ b/layout/mathml/nsMathMLmencloseFrame.cpp
@@ -339,19 +339,18 @@ nsMathMLmencloseFrame::PlaceInternal(Dra
nscoord psi = 0;
nscoord leading = 0;
///////////////
// Thickness of bars and font metrics
nscoord onePixel = nsPresContext::CSSPixelsToAppUnits(1);
float fontSizeInflation = nsLayoutUtils::FontSizeInflationFor(this);
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetFontMetricsForFrame(this, getter_AddRefs(fm),
- fontSizeInflation);
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetFontMetricsForFrame(this, fontSizeInflation);
GetRuleThickness(aDrawTarget, fm, mRuleThickness);
if (mRuleThickness < onePixel) {
mRuleThickness = onePixel;
}
char16_t one = '1';
nsBoundingMetrics bmOne =
nsLayoutUtils::AppUnitBoundsOfString(&one, 1, *fm, aDrawTarget);
--- a/layout/mathml/nsMathMLmfencedFrame.cpp
+++ b/layout/mathml/nsMathMLmfencedFrame.cpp
@@ -218,19 +218,18 @@ nsMathMLmfencedFrame::Reflow(nsPresConte
mPresentationData.flags &= ~NS_MATHML_ERROR;
aDesiredSize.ClearSize();
aDesiredSize.SetBlockStartAscent(0);
aDesiredSize.mBoundingMetrics = nsBoundingMetrics();
int32_t i;
const nsStyleFont* font = StyleFont();
float fontSizeInflation = nsLayoutUtils::FontSizeInflationFor(this);
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetFontMetricsForFrame(this, getter_AddRefs(fm),
- fontSizeInflation);
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetFontMetricsForFrame(this, fontSizeInflation);
nscoord axisHeight, em;
GetAxisHeight(aReflowState.rendContext->GetDrawTarget(), fm, axisHeight);
GetEmHeight(fm, em);
// leading to be left at the top and the bottom of stretched chars
nscoord leading = NSToCoordRound(0.2f * em);
/////////////
// Reflow children
@@ -607,19 +606,18 @@ GetMaxCharWidth(nsPresContext* aPr
/* virtual */ void
nsMathMLmfencedFrame::GetIntrinsicISizeMetrics(nsRenderingContext* aRenderingContext, nsHTMLReflowMetrics& aDesiredSize)
{
nscoord width = 0;
nsPresContext* presContext = PresContext();
const nsStyleFont* font = StyleFont();
float fontSizeInflation = nsLayoutUtils:: FontSizeInflationFor(this);
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetFontMetricsForFrame(this, getter_AddRefs(fm),
- fontSizeInflation);
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetFontMetricsForFrame(this, fontSizeInflation);
nscoord em;
GetEmHeight(fm, em);
if (mOpenChar) {
width +=
GetMaxCharWidth(presContext, aRenderingContext->GetDrawTarget(),
fontSizeInflation, mOpenChar,
NS_MATHML_OPERATOR_FORM_PREFIX, font->mScriptLevel, em);
--- a/layout/mathml/nsMathMLmfracFrame.cpp
+++ b/layout/mathml/nsMathMLmfracFrame.cpp
@@ -213,19 +213,18 @@ nsMathMLmfracFrame::PlaceInternal(DrawTa
}
GetReflowAndBoundingMetricsFor(frameNum, sizeNum, bmNum);
GetReflowAndBoundingMetricsFor(frameDen, sizeDen, bmDen);
nsPresContext* presContext = PresContext();
nscoord onePixel = nsPresContext::CSSPixelsToAppUnits(1);
float fontSizeInflation = nsLayoutUtils::FontSizeInflationFor(this);
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetFontMetricsForFrame(this, getter_AddRefs(fm),
- fontSizeInflation);
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetFontMetricsForFrame(this, fontSizeInflation);
nscoord defaultRuleThickness, axisHeight;
nscoord oneDevPixel = fm->AppUnitsPerDevPixel();
gfxFont* mathFont = fm->GetThebesFontGroup()->GetFirstMathFont();
if (mathFont) {
defaultRuleThickness =
mathFont->GetMathConstant(gfxFontEntry::FractionRuleThickness,
oneDevPixel);
--- a/layout/mathml/nsMathMLmmultiscriptsFrame.cpp
+++ b/layout/mathml/nsMathMLmmultiscriptsFrame.cpp
@@ -180,19 +180,18 @@ nsMathMLmmultiscriptsFrame::PlaceMultiSc
aFrame->ReportErrorToConsole("NoBase");
else
aFrame->ReportChildCountError();
return aFrame->ReflowError(aDrawTarget, aDesiredSize);
}
// get x-height (an ex)
const nsStyleFont* font = aFrame->StyleFont();
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetFontMetricsForFrame(baseFrame, getter_AddRefs(fm),
- aFontSizeInflation);
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetFontMetricsForFrame(baseFrame, aFontSizeInflation);
nscoord xHeight = fm->XHeight();
nscoord oneDevPixel = fm->AppUnitsPerDevPixel();
gfxFont* mathFont = fm->GetThebesFontGroup()->GetFirstMathFont();
// scriptspace from TeX for extra spacing after sup/subscript
nscoord scriptSpace;
if (mathFont) {
--- a/layout/mathml/nsMathMLmoFrame.cpp
+++ b/layout/mathml/nsMathMLmoFrame.cpp
@@ -357,19 +357,18 @@ nsMathMLmoFrame::ProcessOperatorData()
nsMathMLOperators::LookupOperator(data, form, &mFlags, &lspace, &rspace);
// Spacing is zero if our outermost embellished operator is not in an
// inferred mrow.
if (!NS_MATHML_OPERATOR_EMBELLISH_IS_ISOLATED(mFlags) &&
(lspace || rspace)) {
// Cache the default values of lspace and rspace.
// since these values are relative to the 'em' unit, convert to twips now
nscoord em;
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetFontMetricsForFrame(this, getter_AddRefs(fm),
- fontSizeInflation);
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetFontMetricsForFrame(this, fontSizeInflation);
GetEmHeight(fm, em);
mEmbellishData.leadingSpace = NSToCoordRound(lspace * em);
mEmbellishData.trailingSpace = NSToCoordRound(rspace * em);
// tuning if we don't want too much extra space when we are a script.
// (with its fonts, TeX sets lspace=0 & rspace=0 as soon as scriptlevel>0.
// Our fonts can be anything, so...)
@@ -614,19 +613,18 @@ nsMathMLmoFrame::Stretch(DrawTarget*
return NS_OK;
}
mPresentationData.flags |= NS_MATHML_STRETCH_DONE;
nsIFrame* firstChild = mFrames.FirstChild();
// get the axis height;
float fontSizeInflation = nsLayoutUtils::FontSizeInflationFor(this);
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetFontMetricsForFrame(this, getter_AddRefs(fm),
- fontSizeInflation);
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetFontMetricsForFrame(this, fontSizeInflation);
nscoord axisHeight, height;
GetAxisHeight(aDrawTarget, fm, axisHeight);
// get the leading to be left at the top and the bottom of the stretched char
// this seems more reliable than using fm->GetLeading() on suspicious fonts
nscoord em;
GetEmHeight(fm, em);
nscoord leading = NSToCoordRound(0.2f * em);
--- a/layout/mathml/nsMathMLmrootFrame.cpp
+++ b/layout/mathml/nsMathMLmrootFrame.cpp
@@ -220,20 +220,19 @@ nsMathMLmrootFrame::Reflow(nsPresContext
// Call DidReflow() for the child frames we successfully did reflow.
DidReflowChildren(mFrames.FirstChild(), childFrame);
return;
}
////////////
// Prepare the radical symbol and the overline bar
- RefPtr<nsFontMetrics> fm;
float fontSizeInflation = nsLayoutUtils::FontSizeInflationFor(this);
- nsLayoutUtils::GetFontMetricsForFrame(this, getter_AddRefs(fm),
- fontSizeInflation);
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetFontMetricsForFrame(this, fontSizeInflation);
nscoord ruleThickness, leading, psi;
GetRadicalParameters(fm, StyleFont()->mMathDisplay ==
NS_MATHML_DISPLAYSTYLE_BLOCK,
ruleThickness, leading, psi);
// built-in: adjust clearance psi to emulate \mathstrut using '1' (TexBook, p.131)
char16_t one = '1';
@@ -377,19 +376,18 @@ nsMathMLmrootFrame::GetIntrinsicISizeMet
nscoord indexWidth =
nsLayoutUtils::IntrinsicForContainer(aRenderingContext, indexFrame,
nsLayoutUtils::PREF_ISIZE);
nscoord sqrWidth = mSqrChar.GetMaxWidth(PresContext(),
aRenderingContext->GetDrawTarget(),
fontSizeInflation);
nscoord dxSqr;
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetFontMetricsForFrame(this, getter_AddRefs(fm),
- fontSizeInflation);
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetFontMetricsForFrame(this, fontSizeInflation);
GetRadicalXOffsets(indexWidth, sqrWidth, fm, nullptr, &dxSqr);
nscoord width = dxSqr + sqrWidth + baseWidth;
aDesiredSize.Width() = width;
aDesiredSize.mBoundingMetrics.width = width;
aDesiredSize.mBoundingMetrics.leftBearing = 0;
aDesiredSize.mBoundingMetrics.rightBearing = width;
--- a/layout/mathml/nsMathMLmtableFrame.cpp
+++ b/layout/mathml/nsMathMLmtableFrame.cpp
@@ -501,19 +501,18 @@ ParseSpacingAttribute(nsMathMLmtableFram
return;
}
}
nscoord value;
nscoord value2;
// Set defaults
float fontSizeInflation = nsLayoutUtils::FontSizeInflationFor(aFrame);
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetFontMetricsForFrame(aFrame, getter_AddRefs(fm),
- fontSizeInflation);
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetFontMetricsForFrame(aFrame, fontSizeInflation);
if (nsGkAtoms::rowspacing_ == aAttribute) {
value = kDefaultRowspacingEx * fm->XHeight();
value2 = 0;
} else if (nsGkAtoms::columnspacing_ == aAttribute) {
value = kDefaultColumnspacingEm * fm->EmHeight();
value2 = 0;
} else {
value = kDefaultFramespacingArg0Em * fm->EmHeight();
@@ -877,18 +876,18 @@ nsMathMLmtableOuterFrame::Reflow(nsPresC
}
}
// in other situations, fallback to center
aDesiredSize.SetBlockStartAscent(dy + blockSize / 2);
break;
case eAlign_axis:
default: {
// XXX should instead use style data from the row of reference here ?
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetInflatedFontMetricsForFrame(this, getter_AddRefs(fm));
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetInflatedFontMetricsForFrame(this);
nscoord axisHeight;
GetAxisHeight(aReflowState.rendContext->GetDrawTarget(), fm, axisHeight);
if (rowFrame) {
// anchor the table on the axis of the row of reference
// XXX fallback to baseline because it is a hard problem
// XXX need to fetch the axis of the row; would need rowalign=axis to work better
nscoord rowAscent = ((nsTableRowFrame*)rowFrame)->GetMaxCellAscent();
if (rowAscent) { // the row has at least one cell with 'vertical-align: baseline'
--- a/layout/mathml/nsMathMLmunderoverFrame.cpp
+++ b/layout/mathml/nsMathMLmunderoverFrame.cpp
@@ -393,19 +393,18 @@ nsMathMLmunderoverFrame::Place(DrawTarge
GetReflowAndBoundingMetricsFor(overFrame, overSize, bmOver);
}
nscoord onePixel = nsPresContext::CSSPixelsToAppUnits(1);
////////////////////
// Place Children
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetFontMetricsForFrame(this, getter_AddRefs(fm),
- fontSizeInflation);
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetFontMetricsForFrame(this, fontSizeInflation);
nscoord xHeight = fm->XHeight();
nscoord oneDevPixel = fm->AppUnitsPerDevPixel();
gfxFont* mathFont = fm->GetThebesFontGroup()->GetFirstMathFont();
nscoord ruleThickness;
GetRuleThickness (aDrawTarget, fm, ruleThickness);
--- a/layout/style/nsFontFaceUtils.cpp
+++ b/layout/style/nsFontFaceUtils.cpp
@@ -29,20 +29,18 @@ StyleContextContainsFont(nsStyleContext*
// first, check if the family name is in the fontlist
const nsString& familyName = aFont->FamilyName();
if (!aStyleContext->StyleFont()->mFont.fontlist.Contains(familyName)) {
return false;
}
// family name is in the fontlist, check to see if the font group
// associated with the frame includes the specific userfont
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetFontMetricsForStyleContext(aStyleContext,
- getter_AddRefs(fm),
- 1.0f);
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetFontMetricsForStyleContext(aStyleContext, 1.0f);
if (fm->GetThebesFontGroup()->ContainsUserFont(aFont)) {
return true;
}
return false;
}
--- a/layout/style/nsRuleNode.cpp
+++ b/layout/style/nsRuleNode.cpp
@@ -330,20 +330,17 @@ GetMetricsFor(nsPresContext* aPresContex
}
nsFontMetrics::Params params;
params.language = aStyleFont->mLanguage;
params.explicitLanguage = aStyleFont->mExplicitLanguage;
params.orientation = orientation;
params.userFontSet =
aUseUserFontSet ? aPresContext->GetUserFontSet() : nullptr;
params.textPerf = aPresContext->GetTextPerfMetrics();
- RefPtr<nsFontMetrics> fm;
- aPresContext->DeviceContext()->
- GetMetricsFor(font, params, *getter_AddRefs(fm));
- return fm.forget();
+ return aPresContext->DeviceContext()->GetMetricsFor(font, params);
}
static nsSize CalcViewportUnitsScale(nsPresContext* aPresContext)
{
// The caller is making use of viewport units, so notify the pres context
// that it will need to rebuild the rule tree if the size of the viewport
// changes.
--- a/layout/xul/nsListBoxBodyFrame.cpp
+++ b/layout/xul/nsListBoxBodyFrame.cpp
@@ -192,18 +192,18 @@ nsListBoxBodyFrame::Init(nsIContent*
nsIScrollableFrame* scrollFrame = do_QueryFrame(aParent);
if (scrollFrame) {
nsIFrame* verticalScrollbar = scrollFrame->GetScrollbarBox(true);
nsScrollbarFrame* scrollbarFrame = do_QueryFrame(verticalScrollbar);
if (scrollbarFrame) {
scrollbarFrame->SetScrollbarMediatorContent(GetContent());
}
}
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetFontMetricsForFrame(this, getter_AddRefs(fm), 1.0f);
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetFontMetricsForFrame(this, 1.0f);
mRowHeight = fm->MaxHeight();
}
void
nsListBoxBodyFrame::DestroyFrom(nsIFrame* aDestructRoot)
{
// make sure we cancel any posted callbacks.
if (mReflowCallbackPosted)
@@ -723,19 +723,18 @@ nsListBoxBodyFrame::ComputeIntrinsicISiz
uint32_t textCount = child->GetChildCount();
for (uint32_t j = 0; j < textCount; ++j) {
nsIContent* text = child->GetChildAt(j);
if (text && text->IsNodeOfType(nsINode::eTEXT)) {
text->AppendTextTo(value);
}
}
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetFontMetricsForStyleContext(styleContext,
- getter_AddRefs(fm));
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetFontMetricsForStyleContext(styleContext);
nscoord textWidth =
nsLayoutUtils::AppUnitWidthOfStringBidi(value, this, *fm,
*rendContext);
textWidth += width;
if (textWidth > largestWidth)
largestWidth = textWidth;
--- a/layout/xul/nsTextBoxFrame.cpp
+++ b/layout/xul/nsTextBoxFrame.cpp
@@ -453,18 +453,18 @@ nsTextBoxFrame::DrawText(nsRenderingCont
strikeStyle = style;
decorMask &= ~NS_STYLE_TEXT_DECORATION_LINE_LINE_THROUGH;
decorations |= NS_STYLE_TEXT_DECORATION_LINE_LINE_THROUGH;
}
}
} while (0 != decorMask &&
(f = nsLayoutUtils::GetParentOrPlaceholderFor(f)));
- RefPtr<nsFontMetrics> fontMet;
- nsLayoutUtils::GetFontMetricsForFrame(this, getter_AddRefs(fontMet), 1.0f);
+ RefPtr<nsFontMetrics> fontMet =
+ nsLayoutUtils::GetFontMetricsForFrame(this, 1.0f);
fontMet->SetVertical(wm.IsVertical());
fontMet->SetTextOrientation(StyleVisibility()->mTextOrientation);
nscoord offset;
nscoord size;
nscoord ascent = fontMet->MaxAscent();
nsPoint baselinePt;
@@ -628,18 +628,18 @@ nsTextBoxFrame::CalculateTitleForWidth(n
{
DrawTarget* drawTarget = aRenderingContext.GetDrawTarget();
if (mTitle.IsEmpty()) {
mCroppedTitle.Truncate();
return 0;
}
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetFontMetricsForFrame(this, getter_AddRefs(fm), 1.0f);
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetFontMetricsForFrame(this, 1.0f);
// see if the text will completely fit in the width given
nscoord titleWidth =
nsLayoutUtils::AppUnitWidthOfStringBidi(mTitle, this, *fm,
aRenderingContext);
if (titleWidth <= aWidth) {
mCroppedTitle = mTitle;
if (HasRTLChars(mTitle) ||
@@ -964,18 +964,18 @@ nsTextBoxFrame::DoLayout(nsBoxLayoutStat
CalcDrawRect(*aBoxLayoutState.GetRenderingContext());
const nsStyleText* textStyle = StyleText();
nsRect scrollBounds(nsPoint(0, 0), GetSize());
nsRect textRect = mTextDrawRect;
- RefPtr<nsFontMetrics> fontMet;
- nsLayoutUtils::GetFontMetricsForFrame(this, getter_AddRefs(fontMet), 1.0f);
+ RefPtr<nsFontMetrics> fontMet =
+ nsLayoutUtils::GetFontMetricsForFrame(this, 1.0f);
nsBoundingMetrics metrics =
fontMet->GetInkBoundsForVisualOverflow(mCroppedTitle.get(),
mCroppedTitle.Length(),
aBoxLayoutState.GetRenderingContext()->GetDrawTarget());
WritingMode wm = GetWritingMode();
LogicalRect tr(wm, textRect, GetSize());
@@ -1025,18 +1025,18 @@ nsTextBoxFrame::MarkIntrinsicISizesDirty
nsTextBoxFrameSuper::MarkIntrinsicISizesDirty();
}
void
nsTextBoxFrame::GetTextSize(nsRenderingContext& aRenderingContext,
const nsString& aString,
nsSize& aSize, nscoord& aAscent)
{
- RefPtr<nsFontMetrics> fontMet;
- nsLayoutUtils::GetFontMetricsForFrame(this, getter_AddRefs(fontMet), 1.0f);
+ RefPtr<nsFontMetrics> fontMet =
+ nsLayoutUtils::GetFontMetricsForFrame(this, 1.0f);
aSize.height = fontMet->MaxHeight();
aSize.width =
nsLayoutUtils::AppUnitWidthOfStringBidi(aString, this, *fontMet,
aRenderingContext);
aAscent = fontMet->MaxAscent();
}
void
--- a/layout/xul/tree/nsTreeBodyFrame.cpp
+++ b/layout/xul/tree/nsTreeBodyFrame.cpp
@@ -1244,19 +1244,18 @@ nsTreeBodyFrame::GetCoordsForCellItem(in
nsRect textRect(cellX, cellRect.y, remainWidth, cellRect.height);
// Measure the width of the text. If the width of the text is greater than
// the remaining width available, then we just assume that the text has
// been cropped and use the remaining rect as the text Rect. Otherwise,
// we add in borders and padding to the text dimension and give that back.
nsStyleContext* textContext = GetPseudoStyleContext(nsCSSAnonBoxes::moztreecelltext);
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetFontMetricsForStyleContext(textContext,
- getter_AddRefs(fm));
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetFontMetricsForStyleContext(textContext);
nscoord height = fm->MaxHeight();
nsMargin textMargin;
textContext->StyleMargin()->GetMargin(textMargin);
textRect.Deflate(textMargin);
// Center the text. XXX Obey vertical-align style prop?
if (height < textRect.height) {
@@ -1616,19 +1615,18 @@ nsTreeBodyFrame::GetItemWithinCellAt(nsc
nsStyleContext* textContext = GetPseudoStyleContext(nsCSSAnonBoxes::moztreecelltext);
nsMargin textMargin;
textContext->StyleMargin()->GetMargin(textMargin);
textRect.Deflate(textMargin);
AdjustForBorderPadding(textContext, textRect);
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetFontMetricsForStyleContext(textContext,
- getter_AddRefs(fm));
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetFontMetricsForStyleContext(textContext);
AdjustForCellText(cellText, aRowIndex, aColumn, rc, *fm, textRect);
if (aX >= textRect.x && aX < textRect.x + textRect.width)
return nsCSSAnonBoxes::moztreecelltext;
else
return nsCSSAnonBoxes::moztreecell;
}
@@ -1744,19 +1742,18 @@ nsTreeBodyFrame::GetCellWidth(int32_t aR
// necessary
CheckTextForBidi(cellText);
nsStyleContext* textContext = GetPseudoStyleContext(nsCSSAnonBoxes::moztreecelltext);
// Get the borders and padding for the text.
GetBorderPadding(textContext, bp);
- RefPtr<nsFontMetrics> fm;
- nsLayoutUtils::GetFontMetricsForStyleContext(textContext,
- getter_AddRefs(fm));
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetFontMetricsForStyleContext(textContext);
// Get the width of the text itself
nscoord width = nsLayoutUtils::AppUnitWidthOfStringBidi(cellText, this, *fm,
*aRenderingContext);
nscoord totalTextWidth = width + bp.left + bp.right;
aDesiredSize += totalTextWidth;
return NS_OK;
}
@@ -3725,19 +3722,18 @@ nsTreeBodyFrame::PaintText(int32_t
textRect.Deflate(textMargin);
// Adjust the rect for its border and padding.
nsMargin bp(0,0,0,0);
GetBorderPadding(textContext, bp);
textRect.Deflate(bp);
// Compute our text size.
- RefPtr<nsFontMetrics> fontMet;
- nsLayoutUtils::GetFontMetricsForStyleContext(textContext,
- getter_AddRefs(fontMet));
+ RefPtr<nsFontMetrics> fontMet =
+ nsLayoutUtils::GetFontMetricsForStyleContext(textContext);
nscoord height = fontMet->MaxHeight();
nscoord baseline = fontMet->MaxAscent();
// Center the text. XXX Obey vertical-align style prop?
if (height < textRect.height) {
textRect.y += (textRect.height - height)/2;
textRect.height = height;