--- a/dom/canvas/DocumentRendererChild.cpp
+++ b/dom/canvas/DocumentRendererChild.cpp
@@ -2,29 +2,29 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "mozilla/ipc/DocumentRendererChild.h"
#include "base/basictypes.h"
#include "gfx2DGlue.h"
+#include "gfxContext.h"
#include "gfxPattern.h"
#include "mozilla/gfx/2D.h"
#include "mozilla/RefPtr.h"
#include "nsPIDOMWindow.h"
#include "nsIDOMWindow.h"
#include "nsIDocShell.h"
#include "nsIInterfaceRequestorUtils.h"
#include "nsComponentManagerUtils.h"
#include "nsCSSParser.h"
#include "nsPresContext.h"
#include "nsCOMPtr.h"
#include "nsColor.h"
-#include "gfxContext.h"
#include "nsLayoutUtils.h"
#include "nsContentUtils.h"
#include "nsCSSValue.h"
#include "nsRuleNode.h"
#include "mozilla/gfx/Matrix.h"
using namespace mozilla;
using namespace mozilla::gfx;
--- a/dom/canvas/DocumentRendererChild.h
+++ b/dom/canvas/DocumentRendererChild.h
@@ -1,18 +1,18 @@
/* 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/. */
#ifndef mozilla_dom_DocumentRendererChild
#define mozilla_dom_DocumentRendererChild
+#include "gfxContext.h"
#include "mozilla/ipc/PDocumentRendererChild.h"
#include "nsString.h"
-#include "gfxContext.h"
class nsIDOMWindow;
namespace mozilla {
namespace ipc {
class DocumentRendererChild : public PDocumentRendererChild
{
--- a/dom/canvas/DocumentRendererParent.h
+++ b/dom/canvas/DocumentRendererParent.h
@@ -1,19 +1,19 @@
/* 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/. */
#ifndef mozilla_dom_DocumentRendererParent
#define mozilla_dom_DocumentRendererParent
+#include "gfxContext.h"
#include "mozilla/ipc/PDocumentRendererParent.h"
#include "nsCOMPtr.h"
#include "nsString.h"
-#include "gfxContext.h"
class nsICanvasRenderingContextInternal;
namespace mozilla {
namespace ipc {
class DocumentRendererParent : public PDocumentRendererParent
{
--- a/dom/plugins/ipc/PluginInstanceParent.cpp
+++ b/dom/plugins/ipc/PluginInstanceParent.cpp
@@ -26,17 +26,16 @@
#include "nsNetUtil.h"
#include "nsNPAPIPluginInstance.h"
#include "nsPluginInstanceOwner.h"
#include "nsFocusManager.h"
#include "nsIDOMElement.h"
#ifdef MOZ_X11
#include "gfxXlibSurface.h"
#endif
-#include "gfxContext.h"
#include "gfxUtils.h"
#include "mozilla/gfx/2D.h"
#include "Layers.h"
#include "ImageContainer.h"
#include "GLContext.h"
#include "GLContextProvider.h"
#include "gfxPrefs.h"
#include "LayersLogging.h"
--- a/gfx/layers/basic/BasicDisplayItemLayer.cpp
+++ b/gfx/layers/basic/BasicDisplayItemLayer.cpp
@@ -55,18 +55,17 @@ public:
return;
}
AutoRestoreTransform autoRestoreTransform(aDT);
Matrix transform = aDT->GetTransform();
RefPtr<gfxContext> context = gfxContext::CreateOrNull(aDT, aDeviceOffset);
context->SetMatrix(ThebesMatrix(transform));
- nsRenderingContext ctx(context);
- mItem->Paint(mBuilder, &ctx);
+ mItem->Paint(mBuilder, context);
}
protected:
BasicLayerManager* BasicManager()
{
return static_cast<BasicLayerManager*>(mManager);
}
};
--- a/gfx/layers/wr/WebRenderDisplayItemLayer.cpp
+++ b/gfx/layers/wr/WebRenderDisplayItemLayer.cpp
@@ -156,18 +156,17 @@ WebRenderDisplayItemLayer::PushItemAsBlo
LayoutDevicePoint::FromAppUnits(mItem->ToReferenceFrame(), appUnitsPerDevPixel),
PixelCastJustification::WebRenderHasUnitResolution);
{
dt->ClearRect(imageRect.ToUnknownRect());
RefPtr<gfxContext> context = gfxContext::CreateOrNull(dt, offset.ToUnknownPoint());
MOZ_ASSERT(context);
- nsRenderingContext ctx(context);
- mItem->Paint(mBuilder, &ctx);
+ mItem->Paint(mBuilder, context);
}
wr::ByteBuffer bytes;
bytes.Allocate(recorder->RecordingSize());
DebugOnly<bool> ok = recorder->CopyRecording((char*)bytes.AsSlice().begin().get(), bytes.AsSlice().length());
MOZ_ASSERT(ok);
WrRect dest = aSc.ToRelativeWrRect(imageRect + offset);
--- a/gfx/src/moz.build
+++ b/gfx/src/moz.build
@@ -28,17 +28,16 @@ EXPORTS += [
'nsFontMetrics.h',
'nsGfxCIID.h',
'nsITheme.h',
'nsMargin.h',
'nsPoint.h',
'nsRect.h',
'nsRegion.h',
'nsRegionFwd.h',
- 'nsRenderingContext.h',
'nsSize.h',
'nsThemeConstants.h',
'nsTransform2D.h',
'PingPongRegion.h',
'RegionBuilder.h',
'X11UndefineNone.h'
]
--- a/gfx/src/nsFontMetrics.cpp
+++ b/gfx/src/nsFontMetrics.cpp
@@ -1,27 +1,27 @@
/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* 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 "nsFontMetrics.h"
#include <math.h> // for floor, ceil
#include <algorithm> // for max
+#include "gfxContext.h" // for gfxContext
#include "gfxFontConstants.h" // for NS_FONT_SYNTHESIS_*
#include "gfxPlatform.h" // for gfxPlatform
#include "gfxPoint.h" // for gfxPoint
#include "gfxRect.h" // for gfxRect
#include "gfxTypes.h" // for gfxFloat
#include "nsBoundingMetrics.h" // for nsBoundingMetrics
#include "nsDebug.h" // for NS_ERROR
#include "nsDeviceContext.h" // for nsDeviceContext
#include "nsIAtom.h" // for nsIAtom
#include "nsMathUtils.h" // for NS_round
-#include "nsRenderingContext.h" // for nsRenderingContext
#include "nsString.h" // for nsString
#include "nsStyleConsts.h" // for StyleHyphens::None
#include "mozilla/Assertions.h" // for MOZ_ASSERT
#include "mozilla/UniquePtr.h" // for UniquePtr
class gfxUserFontSet;
using namespace mozilla;
@@ -349,17 +349,17 @@ nsFontMetrics::GetWidth(const char16_t*
}
return 0;
}
// Draw a string using this font handle on the surface passed in.
void
nsFontMetrics::DrawString(const char *aString, uint32_t aLength,
nscoord aX, nscoord aY,
- nsRenderingContext *aContext)
+ gfxContext *aContext)
{
if (aLength == 0)
return;
StubPropertyProvider provider;
AutoTextRun textRun(this, aContext->GetDrawTarget(), aString, aLength);
if (!textRun.get()) {
return;
@@ -368,25 +368,25 @@ nsFontMetrics::DrawString(const char *aS
Range range(0, aLength);
if (mTextRunRTL) {
if (mVertical) {
pt.y += textRun->GetAdvanceWidth(range, &provider);
} else {
pt.x += textRun->GetAdvanceWidth(range, &provider);
}
}
- gfxTextRun::DrawParams params(aContext->ThebesContext());
+ gfxTextRun::DrawParams params(aContext);
params.provider = &provider;
textRun->Draw(range, pt, params);
}
void
nsFontMetrics::DrawString(const char16_t* aString, uint32_t aLength,
nscoord aX, nscoord aY,
- nsRenderingContext *aContext,
+ gfxContext *aContext,
DrawTarget* aTextRunConstructionDrawTarget)
{
if (aLength == 0)
return;
StubPropertyProvider provider;
AutoTextRun textRun(this, aTextRunConstructionDrawTarget, aString, aLength);
if (!textRun.get()) {
@@ -396,17 +396,17 @@ nsFontMetrics::DrawString(const char16_t
Range range(0, aLength);
if (mTextRunRTL) {
if (mVertical) {
pt.y += textRun->GetAdvanceWidth(range, &provider);
} else {
pt.x += textRun->GetAdvanceWidth(range, &provider);
}
}
- gfxTextRun::DrawParams params(aContext->ThebesContext());
+ gfxTextRun::DrawParams params(aContext);
params.provider = &provider;
textRun->Draw(range, pt, params);
}
static nsBoundingMetrics
GetTextBoundingMetrics(nsFontMetrics* aMetrics, const char16_t* aString,
uint32_t aLength, mozilla::gfx::DrawTarget* aDrawTarget,
gfxFont::BoundingBoxType aType)
--- a/gfx/src/nsFontMetrics.h
+++ b/gfx/src/nsFontMetrics.h
@@ -13,21 +13,21 @@
#include "mozilla/RefPtr.h" // for RefPtr
#include "nsCOMPtr.h" // for nsCOMPtr
#include "nsCoord.h" // for nscoord
#include "nsError.h" // for nsresult
#include "nsFont.h" // for nsFont
#include "nsISupports.h" // for NS_INLINE_DECL_REFCOUNTING
#include "nscore.h" // for char16_t
+class gfxContext;
class gfxUserFontSet;
class gfxTextPerfMetrics;
class nsDeviceContext;
class nsIAtom;
-class nsRenderingContext;
struct nsBoundingMetrics;
/**
* Font metrics
*
* This class may be somewhat misnamed. A better name might be
* nsFontList. The style system uses the nsFont struct for various
* font properties, one of which is font-family, which can contain a
@@ -195,20 +195,20 @@ public:
nscoord GetWidth(const char* aString, uint32_t aLength,
DrawTarget* aDrawTarget);
nscoord GetWidth(const char16_t* aString, uint32_t aLength,
DrawTarget* aDrawTarget);
// Draw a string using this font handle on the surface passed in.
void DrawString(const char *aString, uint32_t aLength,
nscoord aX, nscoord aY,
- nsRenderingContext *aContext);
+ gfxContext *aContext);
void DrawString(const char16_t* aString, uint32_t aLength,
nscoord aX, nscoord aY,
- nsRenderingContext *aContext,
+ gfxContext *aContext,
DrawTarget* aTextRunConstructionDrawTarget);
nsBoundingMetrics GetBoundingMetrics(const char16_t *aString,
uint32_t aLength,
DrawTarget* aDrawTarget);
// Returns the LOOSE_INK_EXTENTS bounds of the text for determing the
// overflow area of the string.
--- a/gfx/src/nsITheme.h
+++ b/gfx/src/nsITheme.h
@@ -10,19 +10,19 @@
#define nsITheme_h_
#include "nsISupports.h"
#include "nsCOMPtr.h"
#include "nsColor.h"
#include "Units.h"
struct nsRect;
+class gfxContext;
class nsAttrValue;
class nsPresContext;
-class nsRenderingContext;
class nsDeviceContext;
class nsIFrame;
class nsIAtom;
class nsIWidget;
// IID for the nsITheme interface
// {7329f760-08cb-450f-8225-dae729096dec}
#define NS_ITHEME_IID \
@@ -50,17 +50,17 @@ public:
/**
* Draw the actual theme background.
* @param aContext the context to draw into
* @param aFrame the frame for the widget that we're drawing
* @param aWidgetType the -moz-appearance value to draw
* @param aRect the rectangle defining the area occupied by the widget
* @param aDirtyRect the rectangle that needs to be drawn
*/
- NS_IMETHOD DrawWidgetBackground(nsRenderingContext* aContext,
+ NS_IMETHOD DrawWidgetBackground(gfxContext* aContext,
nsIFrame* aFrame,
uint8_t aWidgetType,
const nsRect& aRect,
const nsRect& aDirtyRect) = 0;
/**
* Get the computed CSS border for the widget, in pixels.
*/
deleted file mode 100644
--- a/gfx/src/nsRenderingContext.h
+++ /dev/null
@@ -1,41 +0,0 @@
-/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* 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/. */
-
-#ifndef NSRENDERINGCONTEXT__H__
-#define NSRENDERINGCONTEXT__H__
-
-#include "gfxContext.h"
-#include "mozilla/Attributes.h"
-#include "nsCOMPtr.h"
-#include "mozilla/RefPtr.h"
-
-namespace mozilla {
-namespace gfx {
-class DrawTarget;
-} // namespace gfx
-} // namespace mozilla
-
-class MOZ_STACK_CLASS nsRenderingContext final
-{
- typedef mozilla::gfx::DrawTarget DrawTarget;
-
-public:
- explicit nsRenderingContext(gfxContext* aThebesContext)
- : mThebes(aThebesContext)
- {}
-
- explicit nsRenderingContext(already_AddRefed<gfxContext>&& aThebesContext)
- : mThebes(aThebesContext)
- {}
-
- // These accessors will never return null.
- gfxContext *ThebesContext() { return mThebes; }
- DrawTarget *GetDrawTarget() { return mThebes->GetDrawTarget(); }
-
-private:
- RefPtr<gfxContext> mThebes;
-};
-
-#endif // NSRENDERINGCONTEXT__H__
--- a/layout/base/GeckoRestyleManager.cpp
+++ b/layout/base/GeckoRestyleManager.cpp
@@ -6,16 +6,17 @@
/**
* Code responsible for managing style changes: tracking what style
* changes need to happen, scheduling them, and doing them.
*/
#include "mozilla/GeckoRestyleManager.h"
#include <algorithm> // For std::max
+#include "gfxContext.h"
#include "mozilla/EffectSet.h"
#include "mozilla/EventStates.h"
#include "mozilla/ViewportFrame.h"
#include "mozilla/css/StyleRule.h" // For nsCSSSelector
#include "nsLayoutUtils.h"
#include "AnimationCommon.h" // For GetLayerAnimationInfo
#include "FrameLayerBuilder.h"
#include "GeckoProfiler.h"
@@ -26,17 +27,16 @@
#include "nsStyleUtil.h"
#include "nsCSSFrameConstructor.h"
#include "nsSVGEffects.h"
#include "nsCSSPseudoElements.h"
#include "nsCSSRendering.h"
#include "nsAnimationManager.h"
#include "nsTransitionManager.h"
#include "nsViewManager.h"
-#include "nsRenderingContext.h"
#include "nsSVGIntegrationUtils.h"
#include "nsCSSAnonBoxes.h"
#include "nsContainerFrame.h"
#include "nsPlaceholderFrame.h"
#include "nsBlockFrame.h"
#include "SVGTextFrame.h"
#include "StickyScrollContainer.h"
#include "nsIRootBox.h"
--- a/layout/base/PresShell.cpp
+++ b/layout/base/PresShell.cpp
@@ -40,16 +40,17 @@
#include "mozilla/Unused.h"
#include "mozilla/StyleBackendType.h"
#include <algorithm>
#ifdef XP_WIN
#include "winuser.h"
#endif
+#include "gfxContext.h"
#include "gfxPrefs.h"
#include "gfxUserFontSet.h"
#include "nsPresContext.h"
#include "nsIContent.h"
#include "nsIContentIterator.h"
#include "mozilla/dom/Element.h"
#include "mozilla/dom/Event.h" // for Event::GetEventPopupControlState()
#include "mozilla/dom/PointerEvent.h"
@@ -97,33 +98,31 @@
#include "nsError.h"
#include "nsLayoutUtils.h"
#include "nsViewportInfo.h"
#include "nsCSSRendering.h"
// for |#ifdef DEBUG| code
#include "prenv.h"
#include "nsDisplayList.h"
#include "nsRegion.h"
-#include "nsRenderingContext.h"
#include "nsAutoLayoutPhase.h"
#ifdef MOZ_REFLOW_PERF
#include "nsFontMetrics.h"
#endif
#include "PositionedEventTargeting.h"
#include "nsIReflowCallback.h"
#include "nsPIDOMWindow.h"
#include "nsFocusManager.h"
#include "nsIObjectFrame.h"
#include "nsIObjectLoadingContent.h"
#include "nsNetUtil.h"
#include "nsThreadUtils.h"
#include "nsStyleSheetService.h"
-#include "gfxContext.h"
#include "gfxUtils.h"
#include "nsSMILAnimationController.h"
#include "SVGContentUtils.h"
#include "nsSVGEffects.h"
#include "SVGFragmentIdentifier.h"
#include "nsArenaMemoryStats.h"
#include "nsFrameSelection.h"
@@ -376,17 +375,17 @@ public:
void ClearGrandTotals();
void DisplayTotals(const char * aStr);
void DisplayHTMLTotals(const char * aStr);
void DisplayDiffsInTotals();
void Add(const char * aName, nsIFrame * aFrame);
ReflowCounter * LookUp(const char * aName);
- void PaintCount(const char *aName, nsRenderingContext* aRenderingContext,
+ void PaintCount(const char *aName, gfxContext* aRenderingContext,
nsPresContext *aPresContext, nsIFrame *aFrame,
const nsPoint &aOffset, uint32_t aColor);
FILE * GetOutFile() { return mFD; }
PLHashTable * GetIndiFrameHT() { return mIndiFrameCounts; }
void SetPresContext(nsPresContext * aPresContext) { mPresContext = aPresContext; } // weak reference
@@ -4671,18 +4670,16 @@ PresShell::RenderDocument(const nsRect&
// those integers.
gfxMatrix newTM = aThebesContext->CurrentMatrix().Translate(offset).
Scale(scale, scale).
NudgeToIntegers();
aThebesContext->SetMatrix(newTM);
AutoSaveRestoreRenderingState _(this);
- nsRenderingContext rc(aThebesContext);
-
bool wouldFlushRetainedLayers = false;
PaintFrameFlags flags = PaintFrameFlags::PAINT_IGNORE_SUPPRESSION;
if (aThebesContext->CurrentMatrix().HasNonIntegerTranslation()) {
flags |= PaintFrameFlags::PAINT_IN_TRANSFORM;
}
if (!(aFlags & RENDER_ASYNC_DECODE_IMAGES)) {
flags |= PaintFrameFlags::PAINT_SYNC_DECODE_IMAGES;
}
@@ -4721,17 +4718,17 @@ PresShell::RenderDocument(const nsRect&
flags |= PaintFrameFlags::PAINT_DOCUMENT_RELATIVE;
}
// Don't let drawWindow blow away our retained layer tree
if ((flags & PaintFrameFlags::PAINT_WIDGET_LAYERS) && wouldFlushRetainedLayers) {
flags &= ~PaintFrameFlags::PAINT_WIDGET_LAYERS;
}
- nsLayoutUtils::PaintFrame(&rc, rootFrame, nsRegion(aRect),
+ nsLayoutUtils::PaintFrame(aThebesContext, rootFrame, nsRegion(aRect),
aBackgroundColor,
nsDisplayListBuilderMode::PAINTING,
flags);
return NS_OK;
}
/*
@@ -5061,18 +5058,16 @@ PresShell::PaintRangePaintInfo(const nsT
builder->LineTo(rect.BottomLeft());
builder->LineTo(rect.TopLeft());
}
RefPtr<Path> path = builder->Finish();
ctx->Clip(path);
}
- nsRenderingContext rc(ctx);
-
gfxMatrix initialTM = ctx->CurrentMatrix();
if (resize)
initialTM.Scale(scale, scale);
// translate so that points are relative to the surface area
gfxPoint surfaceOffset =
nsLayoutUtils::PointToGfxPoint(-aArea.TopLeft(), pc->AppUnitsPerDevPixel());
@@ -5097,17 +5092,17 @@ PresShell::PaintRangePaintInfo(const nsT
// frame, so account for that translation too:
gfxPoint rootOffset =
nsLayoutUtils::PointToGfxPoint(rangeInfo->mRootOffset,
pc->AppUnitsPerDevPixel());
ctx->SetMatrix(gfxMatrix(initialTM).Translate(rootOffset));
aArea.MoveBy(-rangeInfo->mRootOffset.x, -rangeInfo->mRootOffset.y);
nsRegion visible(aArea);
RefPtr<LayerManager> layerManager =
- rangeInfo->mList.PaintRoot(&rangeInfo->mBuilder, &rc,
+ rangeInfo->mList.PaintRoot(&rangeInfo->mBuilder, ctx,
nsDisplayList::PAINT_DEFAULT);
aArea.MoveBy(rangeInfo->mRootOffset.x, rangeInfo->mRootOffset.y);
}
// restore the old selection display state
frameSelection->SetDisplaySelection(oldDisplaySelection);
return dt->Snapshot();
@@ -9224,17 +9219,17 @@ PresShell::DoReflow(nsIFrame* target, bo
if (mReflowContinueTimer) {
mReflowContinueTimer->Cancel();
mReflowContinueTimer = nullptr;
}
nsIFrame* rootFrame = mFrameConstructor->GetRootFrame();
// CreateReferenceRenderingContext can return nullptr
- nsRenderingContext rcx(CreateReferenceRenderingContext());
+ RefPtr<gfxContext> rcx(CreateReferenceRenderingContext());
#ifdef DEBUG
mCurrentReflowRoot = target;
#endif
// If the target frame is the root of the frame hierarchy, then
// use all the available space. If it's simply a `reflow root',
// then use the target frame's size as the available space.
@@ -9247,17 +9242,17 @@ PresShell::DoReflow(nsIFrame* target, bo
}
NS_ASSERTION(!target->GetNextInFlow() && !target->GetPrevInFlow(),
"reflow roots should never split");
// Don't pass size directly to the reflow state, since a
// constrained height implies page/column breaking.
LogicalSize reflowSize(wm, size.ISize(wm), NS_UNCONSTRAINEDSIZE);
- ReflowInput reflowInput(mPresContext, target, &rcx, reflowSize,
+ ReflowInput reflowInput(mPresContext, target, rcx, reflowSize,
ReflowInput::CALLER_WILL_INIT);
reflowInput.mOrthogonalLimit = size.BSize(wm);
if (rootFrame == target) {
reflowInput.Init(mPresContext);
// When the root frame is being reflowed with unconstrained block-size
// (which happens when we're called from
@@ -9328,17 +9323,17 @@ PresShell::DoReflow(nsIFrame* target, bo
// Always use boundsRelativeToTarget here, not desiredSize.GetVisualOverflowArea(),
// because for root frames (where they could be different, since root frames
// are allowed to have overflow) the root view bounds need to match the
// viewport bounds; the view manager "window dimensions" code depends on it.
nsContainerFrame::SyncFrameViewAfterReflow(mPresContext, target,
target->GetView(),
boundsRelativeToTarget);
nsContainerFrame::SyncWindowProperties(mPresContext, target,
- target->GetView(), &rcx,
+ target->GetView(), rcx,
nsContainerFrame::SET_ASYNC);
target->DidReflow(mPresContext, nullptr, nsDidReflowStatus::FINISHED);
if (target == rootFrame && size.BSize(wm) == NS_UNCONSTRAINEDSIZE) {
mPresContext->SetVisibleArea(boundsRelativeToTarget);
}
#ifdef DEBUG
@@ -10246,17 +10241,17 @@ PresShell::CountReflows(const char * aNa
if (mReflowCountMgr) {
mReflowCountMgr->Add(aName, aFrame);
}
}
//-------------------------------------------------------------
void
PresShell::PaintCount(const char * aName,
- nsRenderingContext* aRenderingContext,
+ gfxContext* aRenderingContext,
nsPresContext* aPresContext,
nsIFrame * aFrame,
const nsPoint& aOffset,
uint32_t aColor)
{
if (mReflowCountMgr) {
mReflowCountMgr->PaintCount(aName, aRenderingContext, aPresContext,
aFrame, aOffset, aColor);
@@ -10439,38 +10434,38 @@ void ReflowCountMgr::Add(const char * aN
counter->mCount++;
counter->mCounter.Add(1);
}
}
}
//------------------------------------------------------------------
void ReflowCountMgr::PaintCount(const char* aName,
- nsRenderingContext* aRenderingContext,
+ gfxContext* aRenderingContext,
nsPresContext* aPresContext,
nsIFrame* aFrame,
const nsPoint& aOffset,
uint32_t aColor)
{
if (mPaintFrameByFrameCounts &&
nullptr != mIndiFrameCounts &&
aFrame != nullptr) {
char key[KEY_BUF_SIZE_FOR_PTR];
SprintfLiteral(key, "%p", (void*)aFrame);
IndiReflowCounter * counter =
(IndiReflowCounter *)PL_HashTableLookup(mIndiFrameCounts, key);
if (counter != nullptr && counter->mName.EqualsASCII(aName)) {
DrawTarget* drawTarget = aRenderingContext->GetDrawTarget();
int32_t appUnitsPerDevPixel = aPresContext->AppUnitsPerDevPixel();
- aRenderingContext->ThebesContext()->Save();
+ aRenderingContext->Save();
gfxPoint devPixelOffset =
nsLayoutUtils::PointToGfxPoint(aOffset, appUnitsPerDevPixel);
- aRenderingContext->ThebesContext()->SetMatrix(
- aRenderingContext->ThebesContext()->CurrentMatrix().Translate(devPixelOffset));
+ aRenderingContext->SetMatrix(
+ aRenderingContext->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 =
@@ -10503,22 +10498,22 @@ void ReflowCountMgr::PaintCount(const ch
}
nsRect rect(0,0, width+15, height+15);
Rect devPxRect =
NSRectToSnappedRect(rect, appUnitsPerDevPixel, *drawTarget);
ColorPattern black(ToDeviceColor(Color(0.f, 0.f, 0.f, 1.f)));
drawTarget->FillRect(devPxRect, black);
- aRenderingContext->ThebesContext()->SetColor(color2);
+ aRenderingContext->SetColor(color2);
fm->DrawString(buf, len, x+15, y+15, aRenderingContext);
- aRenderingContext->ThebesContext()->SetColor(color);
+ aRenderingContext->SetColor(color);
fm->DrawString(buf, len, x, y, aRenderingContext);
- aRenderingContext->ThebesContext()->Restore();
+ aRenderingContext->Restore();
}
}
}
//------------------------------------------------------------------
int ReflowCountMgr::RemoveItems(PLHashEntry *he, int i, void *arg)
{
char *str = (char *)he->key;
@@ -11173,18 +11168,18 @@ PresShell::ResumePainting()
}
void
nsIPresShell::SyncWindowProperties(nsView* aView)
{
nsIFrame* frame = aView->GetFrame();
if (frame && mPresContext) {
// CreateReferenceRenderingContext can return nullptr
- nsRenderingContext rcx(CreateReferenceRenderingContext());
- nsContainerFrame::SyncWindowProperties(mPresContext, frame, aView, &rcx, 0);
+ RefPtr<gfxContext> rcx(CreateReferenceRenderingContext());
+ nsContainerFrame::SyncWindowProperties(mPresContext, frame, aView, rcx, 0);
}
}
static SheetType
ToSheetType(uint32_t aServiceSheetType)
{
switch (aServiceSheetType) {
case nsIStyleSheetService::AGENT_SHEET:
--- a/layout/base/PresShell.h
+++ b/layout/base/PresShell.h
@@ -313,17 +313,17 @@ public:
NS_DECL_NSIMUTATIONOBSERVER_CONTENTREMOVED
NS_DECL_NSIOBSERVER
#ifdef MOZ_REFLOW_PERF
virtual void DumpReflows() override;
virtual void CountReflows(const char * aName, nsIFrame * aFrame) override;
virtual void PaintCount(const char * aName,
- nsRenderingContext* aRenderingContext,
+ gfxContext* aRenderingContext,
nsPresContext* aPresContext,
nsIFrame * aFrame,
const nsPoint& aOffset,
uint32_t aColor) override;
virtual void SetPaintFrameCount(bool aOn) override;
virtual bool IsPaintingFrameCounts() override;
#endif
--- a/layout/base/RestyleManager.cpp
+++ b/layout/base/RestyleManager.cpp
@@ -816,42 +816,42 @@ RecomputePosition(nsIFrame* aFrame)
return true;
}
// For the absolute positioning case, set up a fake HTML reflow state for
// the frame, and then get the offsets and size from it. If the frame's size
// doesn't need to change, we can simply update the frame position. Otherwise
// we fall back to a reflow.
- nsRenderingContext rc(
- aFrame->PresContext()->PresShell()->CreateReferenceRenderingContext());
+ RefPtr<gfxContext> rc =
+ aFrame->PresContext()->PresShell()->CreateReferenceRenderingContext();
// Construct a bogus parent reflow state so that there's a usable
// containing block reflow state.
nsIFrame* parentFrame = aFrame->GetParent();
WritingMode parentWM = parentFrame->GetWritingMode();
WritingMode frameWM = aFrame->GetWritingMode();
LogicalSize parentSize = parentFrame->GetLogicalSize();
nsFrameState savedState = parentFrame->GetStateBits();
- ReflowInput parentReflowInput(aFrame->PresContext(), parentFrame, &rc,
+ ReflowInput parentReflowInput(aFrame->PresContext(), parentFrame, rc,
parentSize);
parentFrame->RemoveStateBits(~nsFrameState(0));
parentFrame->AddStateBits(savedState);
// The bogus parent state here was created with no parent state of its own,
// and therefore it won't have an mCBReflowInput set up.
// But we may need one (for InitCBReflowInput in a child state), so let's
// try to create one here for the cases where it will be needed.
Maybe<ReflowInput> cbReflowInput;
nsIFrame* cbFrame = parentFrame->GetContainingBlock();
if (cbFrame && (aFrame->GetContainingBlock() != parentFrame ||
parentFrame->IsTableFrame())) {
LogicalSize cbSize = cbFrame->GetLogicalSize();
- cbReflowInput.emplace(cbFrame->PresContext(), cbFrame, &rc, cbSize);
+ cbReflowInput.emplace(cbFrame->PresContext(), cbFrame, rc, cbSize);
cbReflowInput->ComputedPhysicalMargin() = cbFrame->GetUsedMargin();
cbReflowInput->ComputedPhysicalPadding() = cbFrame->GetUsedPadding();
cbReflowInput->ComputedPhysicalBorderPadding() =
cbFrame->GetUsedBorderAndPadding();
parentReflowInput.mCBReflowInput = cbReflowInput.ptr();
}
NS_WARNING_ASSERTION(parentSize.ISize(parentWM) != NS_INTRINSICSIZE &&
--- a/layout/base/nsBidiPresUtils.cpp
+++ b/layout/base/nsBidiPresUtils.cpp
@@ -1,21 +1,21 @@
/* -*- 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 "mozilla/IntegerRange.h"
+#include "gfxContext.h"
#include "nsAutoPtr.h"
#include "nsBidiPresUtils.h"
#include "nsFontMetrics.h"
#include "nsGkAtoms.h"
#include "nsPresContext.h"
-#include "nsRenderingContext.h"
#include "nsBidiUtils.h"
#include "nsCSSFrameConstructor.h"
#include "nsContainerFrame.h"
#include "nsInlineFrame.h"
#include "nsPlaceholderFrame.h"
#include "nsFirstLetterFrame.h"
#include "nsUnicodeProperties.h"
#include "nsTextFrame.h"
@@ -2295,17 +2295,17 @@ nsresult nsBidiPresUtils::ProcessText(co
}
class MOZ_STACK_CLASS nsIRenderingContextBidiProcessor final
: public nsBidiPresUtils::BidiProcessor
{
public:
typedef mozilla::gfx::DrawTarget DrawTarget;
- nsIRenderingContextBidiProcessor(nsRenderingContext* aCtx,
+ nsIRenderingContextBidiProcessor(gfxContext* aCtx,
DrawTarget* aTextRunConstructionDrawTarget,
nsFontMetrics* aFontMetrics,
const nsPoint& aPt)
: mCtx(aCtx)
, mTextRunConstructionDrawTarget(aTextRunConstructionDrawTarget)
, mFontMetrics(aFontMetrics)
, mPt(aPt)
{}
@@ -2339,29 +2339,29 @@ public:
} else {
pt.x += aIOffset;
}
mFontMetrics->DrawString(mText, mLength, pt.x, pt.y,
mCtx, mTextRunConstructionDrawTarget);
}
private:
- nsRenderingContext* mCtx;
+ gfxContext* mCtx;
DrawTarget* mTextRunConstructionDrawTarget;
nsFontMetrics* mFontMetrics;
nsPoint mPt;
const char16_t* mText;
int32_t mLength;
};
nsresult nsBidiPresUtils::ProcessTextForRenderingContext(const char16_t* aText,
int32_t aLength,
nsBidiLevel aBaseLevel,
nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
DrawTarget* aTextRunConstructionDrawTarget,
nsFontMetrics& aFontMetrics,
Mode aMode,
nscoord aX,
nscoord aY,
nsBidiPositionResolve* aPosResolve,
int32_t aPosResolveCount,
nscoord* aWidth)
--- a/layout/base/nsBidiPresUtils.h
+++ b/layout/base/nsBidiPresUtils.h
@@ -2,33 +2,33 @@
*
* 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/. */
#ifndef nsBidiPresUtils_h___
#define nsBidiPresUtils_h___
+#include "gfxContext.h"
#include "nsBidi.h"
#include "nsBidiUtils.h"
#include "nsHashKeys.h"
#include "nsCoord.h"
-#include "nsRenderingContext.h"
#ifdef DrawText
#undef DrawText
#endif
struct BidiParagraphData;
struct BidiLineData;
+class gfxContext;
class nsFontMetrics;
class nsIFrame;
class nsBlockFrame;
class nsPresContext;
-class nsRenderingContext;
class nsBlockInFlowLineIterator;
class nsStyleContext;
struct nsSize;
template<class T> class nsTHashtable;
namespace mozilla {
class WritingMode;
class LogicalMargin;
} // namespace mozilla
@@ -208,17 +208,17 @@ public:
* @param aY the y-coordinate to render the string
* @param[in,out] aPosResolve array of logical positions to resolve into visual positions; can be nullptr if this functionality is not required
* @param aPosResolveCount number of items in the aPosResolve array
*/
static nsresult RenderText(const char16_t* aText,
int32_t aLength,
nsBidiLevel aBaseLevel,
nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
DrawTarget* aTextRunConstructionDrawTarget,
nsFontMetrics& aFontMetrics,
nscoord aX,
nscoord aY,
nsBidiPositionResolve* aPosResolve = nullptr,
int32_t aPosResolveCount = 0)
{
return ProcessTextForRenderingContext(aText, aLength, aBaseLevel, aPresContext, aRenderingContext,
@@ -226,17 +226,17 @@ public:
aFontMetrics,
MODE_DRAW, aX, aY, aPosResolve, aPosResolveCount, nullptr);
}
static nscoord MeasureTextWidth(const char16_t* aText,
int32_t aLength,
nsBidiLevel aBaseLevel,
nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
nsFontMetrics& aFontMetrics)
{
nscoord length;
nsresult rv = ProcessTextForRenderingContext(aText, aLength, aBaseLevel, aPresContext,
aRenderingContext,
aRenderingContext.GetDrawTarget(),
aFontMetrics,
MODE_MEASURE, 0, 0, nullptr, 0, &length);
@@ -374,17 +374,17 @@ public:
static nsBidiLevel BidiLevelFromStyle(nsStyleContext* aStyleContext);
private:
static nsresult
ProcessTextForRenderingContext(const char16_t* aText,
int32_t aLength,
nsBidiLevel aBaseLevel,
nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
DrawTarget* aTextRunConstructionDrawTarget,
nsFontMetrics& aFontMetrics,
Mode aMode,
nscoord aX, // DRAW only
nscoord aY, // DRAW only
nsBidiPositionResolve* aPosResolve, /* may be null */
int32_t aPosResolveCount,
nscoord* aWidth /* may be null */);
--- a/layout/base/nsDocumentViewer.cpp
+++ b/layout/base/nsDocumentViewer.cpp
@@ -1,16 +1,17 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=2 sw=2 et tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
/* container for a document and its presentation */
+#include "gfxContext.h"
#include "mozilla/ServoRestyleManager.h"
#include "mozilla/ServoStyleSet.h"
#include "nsAutoPtr.h"
#include "nscore.h"
#include "nsCOMPtr.h"
#include "nsCRT.h"
#include "nsString.h"
#include "nsReadableUtils.h"
@@ -77,17 +78,16 @@
#include "nsGlobalWindow.h"
#include "nsDOMNavigationTiming.h"
#include "nsPIWindowRoot.h"
#include "nsJSEnvironment.h"
#include "nsFocusManager.h"
#include "nsIScrollableFrame.h"
#include "nsStyleSheetService.h"
-#include "nsRenderingContext.h"
#include "nsILoadContext.h"
#include "nsIPrompt.h"
#include "imgIContainer.h" // image animation mode constants
#include "nsSandboxFlags.h"
#include "mozilla/DocLoadingTimelineMarker.h"
@@ -3522,18 +3522,18 @@ nsDocumentViewer::GetContentSizeInternal
// because it won't change some sizes that a style change reflow will.
mDocument->FlushPendingNotifications(FlushType::Layout);
nsIFrame *root = presShell->GetRootFrame();
NS_ENSURE_TRUE(root, NS_ERROR_FAILURE);
nscoord prefWidth;
{
- nsRenderingContext rcx(presShell->CreateReferenceRenderingContext());
- prefWidth = root->GetPrefISize(&rcx);
+ RefPtr<gfxContext> rcx(presShell->CreateReferenceRenderingContext());
+ prefWidth = root->GetPrefISize(rcx);
}
if (prefWidth > aMaxWidth) {
prefWidth = aMaxWidth;
}
nsresult rv = presShell->ResizeReflow(prefWidth, NS_UNCONSTRAINEDSIZE);
NS_ENSURE_SUCCESS(rv, rv);
--- a/layout/base/nsIPresShell.h
+++ b/layout/base/nsIPresShell.h
@@ -46,23 +46,23 @@
#include "nsRefPtrHashtable.h"
#include "nsClassHashtable.h"
#include "nsPresArena.h"
#include "nsIImageLoadingContent.h"
#include "nsMargin.h"
#include "nsFrameState.h"
#include "Units.h"
+class gfxContext;
class nsDocShell;
class nsIDocument;
class nsIFrame;
class nsPresContext;
class nsViewManager;
class nsView;
-class nsRenderingContext;
class nsIPageSequenceFrame;
class nsCanvasFrame;
class nsAString;
class nsCaret;
namespace mozilla {
class AccessibleCaretEventHub;
class CSSStyleSheet;
} // namespace mozilla
@@ -72,17 +72,16 @@ class nsILayoutHistoryState;
class nsIReflowCallback;
class nsIDOMNode;
class nsCSSFrameConstructor;
class nsISelection;
template<class E> class nsCOMArray;
class AutoWeakFrame;
class WeakFrame;
class nsIScrollableFrame;
-class gfxContext;
class nsIDOMEvent;
class nsDisplayList;
class nsDisplayListBuilder;
class nsPIDOMWindowOuter;
struct nsPoint;
class nsINode;
struct nsRect;
class nsRegion;
@@ -1016,17 +1015,17 @@ public:
static void SetVerifyReflowEnable(bool aEnabled);
virtual nsIFrame* GetAbsoluteContainingBlock(nsIFrame* aFrame);
#ifdef MOZ_REFLOW_PERF
virtual void DumpReflows() = 0;
virtual void CountReflows(const char * aName, nsIFrame * aFrame) = 0;
virtual void PaintCount(const char * aName,
- nsRenderingContext* aRenderingContext,
+ gfxContext* aRenderingContext,
nsPresContext * aPresContext,
nsIFrame * aFrame,
const nsPoint& aOffset,
uint32_t aColor) = 0;
virtual void SetPaintFrameCount(bool aOn) = 0;
virtual bool IsPaintingFrameCounts() = 0;
#endif
--- a/layout/base/nsLayoutUtils.cpp
+++ b/layout/base/nsLayoutUtils.cpp
@@ -45,17 +45,17 @@
#include "nsFrameManager.h"
#include "nsBlockFrame.h"
#include "nsBidiPresUtils.h"
#include "imgIContainer.h"
#include "ImageOps.h"
#include "ImageRegion.h"
#include "gfxRect.h"
#include "gfxContext.h"
-#include "nsRenderingContext.h"
+#include "gfxContext.h"
#include "nsIInterfaceRequestorUtils.h"
#include "nsCSSRendering.h"
#include "nsTextFragment.h"
#include "nsThemeConstants.h"
#include "nsPIDOMWindow.h"
#include "nsIDocShell.h"
#include "nsIWidget.h"
#include "gfxMatrix.h"
@@ -3446,17 +3446,17 @@ nsLayoutUtils::ExpireDisplayPortOnAsyncS
// it will call this function again to trigger the next ancestor up the
// chain.
break;
}
}
}
nsresult
-nsLayoutUtils::PaintFrame(nsRenderingContext* aRenderingContext, nsIFrame* aFrame,
+nsLayoutUtils::PaintFrame(gfxContext* aRenderingContext, nsIFrame* aFrame,
const nsRegion& aDirtyRegion, nscolor aBackstop,
nsDisplayListBuilderMode aBuilderMode,
PaintFrameFlags aFlags)
{
PROFILER_LABEL("nsLayoutUtils", "PaintFrame",
js::ProfileEntry::Category::GRAPHICS);
#ifdef MOZ_DUMP_PAINTING
@@ -3544,18 +3544,18 @@ nsLayoutUtils::PaintFrame(nsRenderingCon
// Make visibleRegion and aRenderingContext relative to the
// scrolled frame instead of the root frame.
nsPoint pos = rootScrollableFrame->GetScrollPosition();
visibleRegion.MoveBy(-pos);
if (aRenderingContext) {
gfxPoint devPixelOffset =
nsLayoutUtils::PointToGfxPoint(pos,
presContext->AppUnitsPerDevPixel());
- aRenderingContext->ThebesContext()->SetMatrix(
- aRenderingContext->ThebesContext()->CurrentMatrix().Translate(devPixelOffset));
+ aRenderingContext->SetMatrix(
+ aRenderingContext->CurrentMatrix().Translate(devPixelOffset));
}
}
builder.SetIgnoreScrollFrame(rootScrollFrame);
nsCanvasFrame* canvasFrame =
do_QueryFrame(rootScrollableFrame->GetScrolledFrame());
if (canvasFrame) {
// Use UnionRect here to ensure that areas where the scrollbars
@@ -4883,17 +4883,17 @@ GetDefiniteSizeTakenByBoxSizing(StyleBox
// Handles only -moz-max-content and -moz-min-content, and
// -moz-fit-content for min-width and max-width, since the others
// (-moz-fit-content for width, and -moz-available) have no effect on
// intrinsic widths.
enum eWidthProperty { PROP_WIDTH, PROP_MAX_WIDTH, PROP_MIN_WIDTH };
static bool
GetIntrinsicCoord(const nsStyleCoord& aStyle,
- nsRenderingContext* aRenderingContext,
+ gfxContext* aRenderingContext,
nsIFrame* aFrame,
eWidthProperty aProperty,
nscoord& aResult)
{
NS_PRECONDITION(aProperty == PROP_WIDTH || aProperty == PROP_MAX_WIDTH ||
aProperty == PROP_MIN_WIDTH, "unexpected property");
if (aStyle.GetUnit() != eStyleUnit_Enumerated)
return false;
@@ -4991,17 +4991,17 @@ FormControlShrinksForPercentISize(nsIFra
* @param aStyleMinSize a 'min-width' or 'min-height' property value
* @param aFixedMaxSize if aStyleMaxSize is a definite size then this points to
* the value, otherwise nullptr
* @param aStyleMaxSize a 'max-width' or 'max-height' property value
* @param aFlags same as for IntrinsicForContainer
* @param aContainerWM the container's WM
*/
static nscoord
-AddIntrinsicSizeOffset(nsRenderingContext* aRenderingContext,
+AddIntrinsicSizeOffset(gfxContext* aRenderingContext,
nsIFrame* aFrame,
const nsIFrame::IntrinsicISizeOffsetData& aOffsets,
nsLayoutUtils::IntrinsicISizeType aType,
StyleBoxSizing aBoxSizing,
nscoord aContentSize,
nscoord aContentMinSize,
const nsStyleCoord& aStyleSize,
const nscoord* aFixedMinSize,
@@ -5136,17 +5136,17 @@ AddStateBitToAncestors(nsIFrame* aFrame,
break;
}
f->AddStateBits(aBit);
}
}
/* static */ nscoord
nsLayoutUtils::IntrinsicForAxis(PhysicalAxis aAxis,
- nsRenderingContext* aRenderingContext,
+ gfxContext* aRenderingContext,
nsIFrame* aFrame,
IntrinsicISizeType aType,
const Maybe<LogicalSize>& aPercentageBasis,
uint32_t aFlags,
nscoord aMarginBoxMinSizeClamp)
{
NS_PRECONDITION(aFrame, "null frame");
NS_PRECONDITION(aFrame->GetParent(),
@@ -5390,31 +5390,31 @@ nsLayoutUtils::IntrinsicForAxis(Physical
horizontalAxis ? "horizontal" : "vertical",
result);
#endif
return result;
}
/* static */ nscoord
-nsLayoutUtils::IntrinsicForContainer(nsRenderingContext* aRenderingContext,
+nsLayoutUtils::IntrinsicForContainer(gfxContext* aRenderingContext,
nsIFrame* aFrame,
IntrinsicISizeType aType,
uint32_t aFlags)
{
MOZ_ASSERT(aFrame && aFrame->GetParent());
// We want the size aFrame will contribute to its parent's inline-size.
PhysicalAxis axis =
aFrame->GetParent()->GetWritingMode().PhysicalAxis(eLogicalAxisInline);
return IntrinsicForAxis(axis, aRenderingContext, aFrame, aType, Nothing(), aFlags);
}
/* static */ nscoord
nsLayoutUtils::MinSizeContributionForAxis(PhysicalAxis aAxis,
- nsRenderingContext* aRC,
+ gfxContext* aRC,
nsIFrame* aFrame,
IntrinsicISizeType aType,
uint32_t aFlags)
{
MOZ_ASSERT(aFrame);
MOZ_ASSERT(aFrame->IsFlexOrGridItem(),
"only grid/flex items have this behavior currently");
@@ -5700,31 +5700,31 @@ nsLayoutUtils::ComputeAutoSizeWithIntrin
}
}
return nsSize(width, height);
}
/* static */ nscoord
nsLayoutUtils::MinISizeFromInline(nsIFrame* aFrame,
- nsRenderingContext* aRenderingContext)
+ gfxContext* aRenderingContext)
{
NS_ASSERTION(!aFrame->IsContainerForFontSizeInflation(),
"should not be container for font size inflation");
nsIFrame::InlineMinISizeData data;
DISPLAY_MIN_WIDTH(aFrame, data.mPrevLines);
aFrame->AddInlineMinISize(aRenderingContext, &data);
data.ForceBreak();
return data.mPrevLines;
}
/* static */ nscoord
nsLayoutUtils::PrefISizeFromInline(nsIFrame* aFrame,
- nsRenderingContext* aRenderingContext)
+ gfxContext* aRenderingContext)
{
NS_ASSERTION(!aFrame->IsContainerForFontSizeInflation(),
"should not be container for font size inflation");
nsIFrame::InlinePrefISizeData data;
DISPLAY_PREF_WIDTH(aFrame, data.mPrevLines);
aFrame->AddInlinePrefISize(aRenderingContext, &data);
data.ForceBreak();
@@ -5847,17 +5847,17 @@ nsLayoutUtils::AppUnitWidthOfString(cons
return width;
}
nscoord
nsLayoutUtils::AppUnitWidthOfStringBidi(const char16_t* aString,
uint32_t aLength,
const nsIFrame* aFrame,
nsFontMetrics& aFontMetrics,
- nsRenderingContext& aContext)
+ gfxContext& aContext)
{
nsPresContext* presContext = aFrame->PresContext();
if (presContext->BidiEnabled()) {
nsBidiLevel level =
nsBidiPresUtils::BidiLevelFromStyle(aFrame->StyleContext());
return nsBidiPresUtils::MeasureTextWidth(aString, aLength, level,
presContext, aContext,
aFontMetrics);
@@ -5916,17 +5916,17 @@ nsLayoutUtils::AppUnitBoundsOfString(con
aString += len;
}
return totalMetrics;
}
void
nsLayoutUtils::DrawString(const nsIFrame* aFrame,
nsFontMetrics& aFontMetrics,
- nsRenderingContext* aContext,
+ gfxContext* aContext,
const char16_t* aString,
int32_t aLength,
nsPoint aPoint,
nsStyleContext* aStyleContext,
DrawStringFlags aFlags)
{
nsresult rv = NS_ERROR_FAILURE;
@@ -5960,17 +5960,17 @@ nsLayoutUtils::DrawString(const nsIFrame
}
}
void
nsLayoutUtils::DrawUniDirString(const char16_t* aString,
uint32_t aLength,
nsPoint aPoint,
nsFontMetrics& aFontMetrics,
- nsRenderingContext& aContext)
+ gfxContext& aContext)
{
nscoord x = aPoint.x;
nscoord y = aPoint.y;
uint32_t maxChunkLength = GetMaxChunkLength(aFontMetrics);
if (aLength <= maxChunkLength) {
aFontMetrics.DrawString(aString, aLength, x, y, &aContext,
aContext.GetDrawTarget());
@@ -5998,30 +5998,30 @@ nsLayoutUtils::DrawUniDirString(const ch
}
aLength -= len;
aString += len;
}
}
/* static */ void
nsLayoutUtils::PaintTextShadow(const nsIFrame* aFrame,
- nsRenderingContext* aContext,
+ gfxContext* aContext,
const nsRect& aTextRect,
const nsRect& aDirtyRect,
const nscolor& aForegroundColor,
TextShadowCallback aCallback,
void* aCallbackData)
{
const nsStyleText* textStyle = aFrame->StyleText();
if (!textStyle->HasTextShadow())
return;
// Text shadow happens with the last value being painted at the back,
// ie. it is painted first.
- gfxContext* aDestCtx = aContext->ThebesContext();
+ gfxContext* aDestCtx = aContext;
for (uint32_t i = textStyle->mTextShadow->Length(); i > 0; --i) {
nsCSSShadowItem* shadowDetails = textStyle->mTextShadow->ShadowAt(i - 1);
nsPoint shadowOffset(shadowDetails->mXOffset,
shadowDetails->mYOffset);
nscoord blurRadius = std::max(shadowDetails->mRadius, 0);
nsRect shadowRect(aTextRect);
shadowRect.MoveBy(shadowOffset);
@@ -6035,26 +6035,22 @@ nsLayoutUtils::PaintTextShadow(const nsI
continue;
nscolor shadowColor;
if (shadowDetails->mHasColor)
shadowColor = shadowDetails->mColor;
else
shadowColor = aForegroundColor;
- // Conjure an nsRenderingContext from a gfxContext for drawing the text
- // to blur.
- nsRenderingContext renderingContext(shadowContext);
-
aDestCtx->Save();
aDestCtx->NewPath();
aDestCtx->SetColor(Color::FromABGR(shadowColor));
// The callback will draw whatever we want to blur as a shadow.
- aCallback(&renderingContext, shadowOffset, shadowColor, aCallbackData);
+ aCallback(shadowContext, shadowOffset, shadowColor, aCallbackData);
contextBoxBlur.DoPaint();
aDestCtx->Restore();
}
}
/* static */ nscoord
nsLayoutUtils::GetCenteredFontBaseline(nsFontMetrics* aFontMetrics,
--- a/layout/base/nsLayoutUtils.h
+++ b/layout/base/nsLayoutUtils.h
@@ -30,16 +30,17 @@
#include "mozilla/ReflowOutput.h"
#include "ImageContainer.h"
#include "gfx2DGlue.h"
#include "nsStyleConsts.h"
#include "SVGImageContext.h"
#include <limits>
#include <algorithm>
+class gfxContext;
class nsPresContext;
class nsIContent;
class nsIAtom;
class nsIScrollableFrame;
class nsIDOMEvent;
class nsRegion;
class nsDisplayListBuilder;
enum class nsDisplayListBuilderMode : uint8_t;
@@ -49,17 +50,16 @@ class nsFontFaceList;
class nsIImageLoadingContent;
class nsStyleContext;
class nsBlockFrame;
class nsContainerFrame;
class nsView;
class nsIFrame;
class nsStyleCoord;
class nsStyleCorners;
-class gfxContext;
class nsPIDOMWindowOuter;
class imgIRequest;
class nsIDocument;
struct gfxPoint;
struct nsStyleFont;
struct nsStyleImageOrientation;
struct nsOverflowAreas;
@@ -1089,17 +1089,17 @@ public:
* manager.
* 3) PAINT_WIDGET_LAYERS is not set and aRenderingContext is non-null;
* we paint by construct a BasicLayerManager and calling
* BeginTransactionWithTarget on it. This is desirable if we're doing
* something like drawWindow in a mode where what gets rendered doesn't
* necessarily correspond to what's visible in the window; we don't
* want to mess up the widget's layer tree.
*/
- static nsresult PaintFrame(nsRenderingContext* aRenderingContext, nsIFrame* aFrame,
+ static nsresult PaintFrame(gfxContext* aRenderingContext, nsIFrame* aFrame,
const nsRegion& aDirtyRegion, nscolor aBackstop,
nsDisplayListBuilderMode aBuilderMode,
PaintFrameFlags aFlags = PaintFrameFlags(0));
/**
* Uses a binary search for find where the cursor falls in the line of text
* It also keeps track of the part of the string that has already been
* measured so it doesn't have to keep measuring the same text over and over.
@@ -1390,26 +1390,26 @@ public:
enum {
IGNORE_PADDING = 0x01,
BAIL_IF_REFLOW_NEEDED = 0x02, // returns NS_INTRINSIC_WIDTH_UNKNOWN if so
MIN_INTRINSIC_ISIZE = 0x04, // use min-width/height instead of width/height
ADD_PERCENTS = 0x08, // apply AddPercents also for MIN_ISIZE
};
static nscoord
IntrinsicForAxis(mozilla::PhysicalAxis aAxis,
- nsRenderingContext* aRenderingContext,
+ gfxContext* aRenderingContext,
nsIFrame* aFrame,
IntrinsicISizeType aType,
const mozilla::Maybe<mozilla::LogicalSize>& aPercentageBasis = mozilla::Nothing(),
uint32_t aFlags = 0,
nscoord aMarginBoxMinSizeClamp = NS_MAXSIZE);
/**
* Calls IntrinsicForAxis with aFrame's parent's inline physical axis.
*/
- static nscoord IntrinsicForContainer(nsRenderingContext* aRenderingContext,
+ static nscoord IntrinsicForContainer(gfxContext* aRenderingContext,
nsIFrame* aFrame,
IntrinsicISizeType aType,
uint32_t aFlags = 0);
/**
* Get the definite size contribution of aFrame for the given physical axis.
* This considers the child's 'min-width' property (or 'min-height' if the
* given axis is vertical), and its padding, border, and margin in the
@@ -1422,17 +1422,17 @@ public:
* If the 'min-' property is 'auto' and 'overflow' is not 'visible', then it
* calculates the result as if the 'min-' computed value is zero.
* Otherwise, return NS_UNCONSTRAINEDSIZE.
*
* @note this behavior is specific to Grid/Flexbox (currently) so aFrame
* should be a grid/flex item.
*/
static nscoord MinSizeContributionForAxis(mozilla::PhysicalAxis aAxis,
- nsRenderingContext* aRC,
+ gfxContext* aRC,
nsIFrame* aFrame,
IntrinsicISizeType aType,
uint32_t aFlags = 0);
/**
* This function increases an initial intrinsic size, 'aCurrent', according
* to the given 'aPercent', such that the size-increase makes up exactly
* 'aPercent' percent of the returned value. If 'aPercent' or 'aCurrent' are
@@ -1534,21 +1534,21 @@ public:
* as specified by CSS 2.1 sections 10.3.2 and 10.6.2
*/
static nsSize ComputeAutoSizeWithIntrinsicDimensions(nscoord minWidth, nscoord minHeight,
nscoord maxWidth, nscoord maxHeight,
nscoord tentWidth, nscoord tentHeight);
// Implement nsIFrame::GetPrefISize in terms of nsIFrame::AddInlinePrefISize
static nscoord PrefISizeFromInline(nsIFrame* aFrame,
- nsRenderingContext* aRenderingContext);
+ gfxContext* aRenderingContext);
// Implement nsIFrame::GetMinISize in terms of nsIFrame::AddInlineMinISize
static nscoord MinISizeFromInline(nsIFrame* aFrame,
- nsRenderingContext* aRenderingContext);
+ gfxContext* aRenderingContext);
// Get a suitable foreground color for painting aColor for aFrame.
static nscolor DarkenColorIfNeeded(nsIFrame* aFrame, nscolor aColor);
// Get a suitable foreground color for painting aField for aFrame.
// Type of aFrame is made a template parameter because nsIFrame is not
// a complete type in the header. Type-safety is not harmed given that
// DarkenColorIfNeeded requires an nsIFrame pointer.
@@ -1579,40 +1579,40 @@ public:
}
static nscoord AppUnitWidthOfString(const char16_t *aString,
uint32_t aLength,
nsFontMetrics& aFontMetrics,
DrawTarget* aDrawTarget);
static nscoord AppUnitWidthOfStringBidi(const nsString& aString,
const nsIFrame* aFrame,
nsFontMetrics& aFontMetrics,
- nsRenderingContext& aContext) {
+ gfxContext& aContext) {
return nsLayoutUtils::AppUnitWidthOfStringBidi(aString.get(),
aString.Length(), aFrame,
aFontMetrics, aContext);
}
static nscoord AppUnitWidthOfStringBidi(const char16_t* aString,
uint32_t aLength,
const nsIFrame* aFrame,
nsFontMetrics& aFontMetrics,
- nsRenderingContext& aContext);
+ gfxContext& aContext);
static bool StringWidthIsGreaterThan(const nsString& aString,
nsFontMetrics& aFontMetrics,
DrawTarget* aDrawTarget,
nscoord aWidth);
static nsBoundingMetrics AppUnitBoundsOfString(const char16_t* aString,
uint32_t aLength,
nsFontMetrics& aFontMetrics,
DrawTarget* aDrawTarget);
static void DrawString(const nsIFrame* aFrame,
nsFontMetrics& aFontMetrics,
- nsRenderingContext* aContext,
+ gfxContext* aContext,
const char16_t* aString,
int32_t aLength,
nsPoint aPoint,
nsStyleContext* aStyleContext = nullptr,
DrawStringFlags aFlags = DrawStringFlags::eDefault);
static nsPoint GetBackgroundFirstTilePos(const nsPoint& aDest,
const nsPoint& aFill,
@@ -1620,29 +1620,29 @@ public:
/**
* Supports only LTR or RTL. Bidi (mixed direction) is not supported.
*/
static void DrawUniDirString(const char16_t* aString,
uint32_t aLength,
nsPoint aPoint,
nsFontMetrics& aFontMetrics,
- nsRenderingContext& aContext);
+ gfxContext& aContext);
/**
* Helper function for drawing text-shadow. The callback's job
* is to draw whatever needs to be blurred onto the given context.
*/
- typedef void (* TextShadowCallback)(nsRenderingContext* aCtx,
+ typedef void (* TextShadowCallback)(gfxContext* aCtx,
nsPoint aShadowOffset,
const nscolor& aShadowColor,
void* aData);
static void PaintTextShadow(const nsIFrame* aFrame,
- nsRenderingContext* aContext,
+ gfxContext* aContext,
const nsRect& aTextRect,
const nsRect& aDirtyRect,
const nscolor& aForegroundColor,
TextShadowCallback aCallback,
void* aCallbackData);
/**
* Gets the baseline to vertically center text from a font within a
--- a/layout/forms/nsButtonFrameRenderer.cpp
+++ b/layout/forms/nsButtonFrameRenderer.cpp
@@ -83,31 +83,31 @@ public:
}
#ifdef NS_BUILD_REFCNT_LOGGING
virtual ~nsDisplayButtonBoxShadowOuter() {
MOZ_COUNT_DTOR(nsDisplayButtonBoxShadowOuter);
}
#endif
virtual void Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) override;
+ gfxContext* aCtx) override;
virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder,
bool* aSnap) override;
NS_DISPLAY_DECL_NAME("ButtonBoxShadowOuter", TYPE_BUTTON_BOX_SHADOW_OUTER)
};
nsRect
nsDisplayButtonBoxShadowOuter::GetBounds(nsDisplayListBuilder* aBuilder, bool* aSnap) {
*aSnap = false;
return mFrame->GetVisualOverflowRectRelativeToSelf() + ToReferenceFrame();
}
void
nsDisplayButtonBoxShadowOuter::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) {
+ gfxContext* aCtx) {
nsRect frameRect = nsRect(ToReferenceFrame(), mFrame->GetSize());
nsCSSRendering::PaintBoxShadowOuter(mFrame->PresContext(), *aCtx, mFrame,
frameRect, mVisibleRect);
}
class nsDisplayButtonBorder : public nsDisplayItem {
public:
@@ -122,17 +122,17 @@ public:
}
#endif
virtual void HitTest(nsDisplayListBuilder* aBuilder, const nsRect& aRect,
HitTestState* aState,
nsTArray<nsIFrame*> *aOutFrames) override {
aOutFrames->AppendElement(mFrame);
}
virtual void Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) override;
+ gfxContext* aCtx) override;
virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder,
bool* aSnap) override;
virtual nsDisplayItemGeometry* AllocateGeometry(nsDisplayListBuilder* aBuilder) override;
virtual void ComputeInvalidationRegion(nsDisplayListBuilder* aBuilder,
const nsDisplayItemGeometry* aGeometry,
nsRegion *aInvalidRegion) override;
virtual LayerState GetLayerState(nsDisplayListBuilder* aBuilder,
LayerManager* aManager,
@@ -238,17 +238,17 @@ nsDisplayButtonBorder::ComputeInvalidati
aInvalidRegion->Or(*aInvalidRegion, GetBounds(aBuilder, &snap));
}
nsDisplayItem::ComputeInvalidationRegion(aBuilder, aGeometry, aInvalidRegion);
}
void
nsDisplayButtonBorder::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx)
+ gfxContext* aCtx)
{
NS_ASSERTION(mFrame, "No frame?");
nsPresContext* pc = mFrame->PresContext();
nsRect r = nsRect(ToReferenceFrame(), mFrame->GetSize());
// draw the border and background inside the focus and outline borders
DrawResult result =
mBFR->PaintBorder(aBuilder, pc, *aCtx, mVisibleRect, r);
@@ -276,17 +276,17 @@ public:
}
#endif
nsDisplayItemGeometry* AllocateGeometry(nsDisplayListBuilder* aBuilder) override;
void ComputeInvalidationRegion(nsDisplayListBuilder* aBuilder,
const nsDisplayItemGeometry* aGeometry,
nsRegion *aInvalidRegion) override;
virtual void Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) override;
+ gfxContext* aCtx) override;
virtual LayerState GetLayerState(nsDisplayListBuilder* aBuilder,
LayerManager* aManager,
const ContainerLayerParameters& aParameters) override;
virtual already_AddRefed<Layer> BuildLayer(nsDisplayListBuilder* aBuilder,
LayerManager* aManager,
const ContainerLayerParameters& aContainerParameters) override;
virtual void CreateWebRenderCommands(wr::DisplayListBuilder& aBuilder,
const StackingContextHelper& aSc,
@@ -318,17 +318,17 @@ nsDisplayButtonForeground::ComputeInvali
bool snap;
aInvalidRegion->Or(*aInvalidRegion, GetBounds(aBuilder, &snap));
}
nsDisplayItem::ComputeInvalidationRegion(aBuilder, aGeometry, aInvalidRegion);
}
void nsDisplayButtonForeground::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx)
+ gfxContext* aCtx)
{
nsPresContext *presContext = mFrame->PresContext();
const nsStyleDisplay *disp = mFrame->StyleDisplay();
if (!mFrame->IsThemed(disp) ||
!presContext->GetTheme()->ThemeDrawsFocusForWidget(disp->mAppearance)) {
nsRect r = nsRect(ToReferenceFrame(), mFrame->GetSize());
// Draw the -moz-focus-inner border
@@ -422,17 +422,17 @@ nsButtonFrameRenderer::GetButtonInnerFoc
}
aResult.Inflate(innerFocusPadding);
}
DrawResult
nsButtonFrameRenderer::PaintInnerFocusBorder(
nsDisplayListBuilder* aBuilder,
nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
const nsRect& aDirtyRect,
const nsRect& aRect)
{
// we draw the -moz-focus-inner border just inside the button's
// normal border and padding, to match Windows themes.
nsRect rect;
@@ -452,17 +452,17 @@ nsButtonFrameRenderer::PaintInnerFocusBo
return result;
}
Maybe<nsCSSBorderRenderer>
nsButtonFrameRenderer::CreateInnerFocusBorderRenderer(
nsDisplayListBuilder* aBuilder,
nsPresContext* aPresContext,
- nsRenderingContext* aRenderingContext,
+ gfxContext* aRenderingContext,
const nsRect& aDirtyRect,
const nsRect& aRect)
{
if (mInnerFocusStyle) {
nsRect rect;
GetButtonInnerFocusRect(aRect, rect);
gfx::DrawTarget* dt = aRenderingContext ? aRenderingContext->GetDrawTarget() : nullptr;
@@ -476,17 +476,17 @@ nsButtonFrameRenderer::CreateInnerFocusB
return Nothing();
}
DrawResult
nsButtonFrameRenderer::PaintBorder(
nsDisplayListBuilder* aBuilder,
nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
const nsRect& aDirtyRect,
const nsRect& aRect)
{
// get the button rect this is inside the focus and outline rects
nsRect buttonRect = aRect;
nsStyleContext* context = mFrame->StyleContext();
PaintBorderFlags borderFlags = aBuilder->ShouldSyncDecodeImages()
--- a/layout/forms/nsButtonFrameRenderer.h
+++ b/layout/forms/nsButtonFrameRenderer.h
@@ -5,22 +5,22 @@
#ifndef nsButtonFrameRenderer_h___
#define nsButtonFrameRenderer_h___
#include "imgIContainer.h"
#include "nsMargin.h"
#include "nsCSSRenderingBorders.h"
+class gfxContext;
class nsIFrame;
class nsFrame;
class nsDisplayList;
class nsDisplayListBuilder;
class nsPresContext;
-class nsRenderingContext;
struct nsRect;
class nsStyleContext;
#define NS_BUTTON_RENDERER_FOCUS_INNER_CONTEXT_INDEX 0
#define NS_BUTTON_RENDERER_LAST_CONTEXT_INDEX NS_BUTTON_RENDERER_FOCUS_INNER_CONTEXT_INDEX
class nsButtonFrameRenderer {
@@ -35,29 +35,29 @@ public:
* Create display list items for the button
*/
nsresult DisplayButton(nsDisplayListBuilder* aBuilder,
nsDisplayList* aBackground, nsDisplayList* aForeground);
DrawResult PaintInnerFocusBorder(nsDisplayListBuilder* aBuilder,
nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
const nsRect& aDirtyRect,
const nsRect& aRect);
mozilla::Maybe<nsCSSBorderRenderer> CreateInnerFocusBorderRenderer(nsDisplayListBuilder* aBuilder,
nsPresContext* aPresContext,
- nsRenderingContext* aRenderingContext,
+ gfxContext* aRenderingContext,
const nsRect& aDirtyRect,
const nsRect& aRect);
DrawResult PaintBorder(nsDisplayListBuilder* aBuilder,
nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
const nsRect& aDirtyRect,
const nsRect& aRect);
void SetFrame(nsFrame* aFrame, nsPresContext* aPresContext);
void SetDisabled(bool aDisabled, bool notify);
bool isActive();
--- a/layout/forms/nsComboboxControlFrame.cpp
+++ b/layout/forms/nsComboboxControlFrame.cpp
@@ -1,15 +1,16 @@
/* -*- 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 "nsComboboxControlFrame.h"
+#include "gfxContext.h"
#include "gfxUtils.h"
#include "mozilla/gfx/2D.h"
#include "mozilla/gfx/PathHelpers.h"
#include "nsCOMPtr.h"
#include "nsFocusManager.h"
#include "nsFormControlFrame.h"
#include "nsGkAtoms.h"
#include "nsCSSAnonBoxes.h"
@@ -33,17 +34,16 @@
#include "mozilla/StyleSetHandle.h"
#include "mozilla/StyleSetHandleInlines.h"
#include "nsNodeInfoManager.h"
#include "nsContentCreatorFunctions.h"
#include "nsLayoutUtils.h"
#include "nsDisplayList.h"
#include "nsITheme.h"
#include "nsThemeConstants.h"
-#include "nsRenderingContext.h"
#include "mozilla/Likely.h"
#include <algorithm>
#include "nsTextNode.h"
#include "mozilla/AsyncEventDispatcher.h"
#include "mozilla/EventStates.h"
#include "mozilla/LookAndFeel.h"
#include "mozilla/MouseEvents.h"
#include "mozilla/Unused.h"
@@ -730,17 +730,17 @@ static void printSize(char * aDesc, nsco
}
#endif
//-------------------------------------------------------------------
//-- Main Reflow for the Combobox
//-------------------------------------------------------------------
nscoord
-nsComboboxControlFrame::GetIntrinsicISize(nsRenderingContext* aRenderingContext,
+nsComboboxControlFrame::GetIntrinsicISize(gfxContext* aRenderingContext,
nsLayoutUtils::IntrinsicISizeType aType)
{
// get the scrollbar width, we'll use this later
nscoord scrollbarWidth = 0;
nsPresContext* presContext = PresContext();
if (mListControlFrame) {
nsIScrollableFrame* scrollable = do_QueryFrame(mListControlFrame);
NS_ASSERTION(scrollable, "List must be a scrollable frame");
@@ -786,26 +786,26 @@ nsComboboxControlFrame::GetIntrinsicISiz
displayISize += scrollbarWidth;
}
return displayISize;
}
nscoord
-nsComboboxControlFrame::GetMinISize(nsRenderingContext *aRenderingContext)
+nsComboboxControlFrame::GetMinISize(gfxContext *aRenderingContext)
{
nscoord minISize;
DISPLAY_MIN_WIDTH(this, minISize);
minISize = GetIntrinsicISize(aRenderingContext, nsLayoutUtils::MIN_ISIZE);
return minISize;
}
nscoord
-nsComboboxControlFrame::GetPrefISize(nsRenderingContext *aRenderingContext)
+nsComboboxControlFrame::GetPrefISize(gfxContext *aRenderingContext)
{
nscoord prefISize;
DISPLAY_PREF_WIDTH(this, prefISize);
prefISize = GetIntrinsicISize(aRenderingContext, nsLayoutUtils::PREF_ISIZE);
return prefISize;
}
void
@@ -1534,22 +1534,22 @@ public:
}
#ifdef NS_BUILD_REFCNT_LOGGING
virtual ~nsDisplayComboboxFocus() {
MOZ_COUNT_DTOR(nsDisplayComboboxFocus);
}
#endif
virtual void Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) override;
+ gfxContext* aCtx) override;
NS_DISPLAY_DECL_NAME("ComboboxFocus", TYPE_COMBOBOX_FOCUS)
};
void nsDisplayComboboxFocus::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx)
+ gfxContext* aCtx)
{
static_cast<nsComboboxControlFrame*>(mFrame)
->PaintFocus(*aCtx->GetDrawTarget(), ToReferenceFrame());
}
void
nsComboboxControlFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
--- a/layout/forms/nsComboboxControlFrame.h
+++ b/layout/forms/nsComboboxControlFrame.h
@@ -72,19 +72,19 @@ public:
nsIContent* GetDisplayNode() { return mDisplayContent; }
nsIFrame* CreateFrameForDisplayNode();
#ifdef ACCESSIBILITY
virtual mozilla::a11y::AccType AccessibleType() override;
#endif
- virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override;
+ virtual nscoord GetMinISize(gfxContext *aRenderingContext) override;
- virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override;
+ virtual nscoord GetPrefISize(gfxContext *aRenderingContext) override;
virtual void Reflow(nsPresContext* aCX,
ReflowOutput& aDesiredSize,
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus) override;
virtual nsresult HandleEvent(nsPresContext* aPresContext,
mozilla::WidgetGUIEvent* aEvent,
@@ -244,17 +244,17 @@ protected:
// a resize reflow is pending, don't show it yet
eDropDownPositionPendingResize,
// the dropdown has its final size and position and can be displayed here
eDropDownPositionFinal
};
DropDownPositionState AbsolutelyPositionDropDown();
// Helper for GetMinISize/GetPrefISize
- nscoord GetIntrinsicISize(nsRenderingContext* aRenderingContext,
+ nscoord GetIntrinsicISize(gfxContext* aRenderingContext,
nsLayoutUtils::IntrinsicISizeType aType);
class RedisplayTextEvent : public mozilla::Runnable {
public:
NS_DECL_NSIRUNNABLE
explicit RedisplayTextEvent(nsComboboxControlFrame *c) : mControlFrame(c) {}
void Revoke() { mControlFrame = nullptr; }
private:
--- a/layout/forms/nsDateTimeControlFrame.cpp
+++ b/layout/forms/nsDateTimeControlFrame.cpp
@@ -121,17 +121,17 @@ nsDateTimeControlFrame::HandleBlurEvent(
nsCOMPtr<nsIDateTimeInputArea> inputAreaContent =
do_QueryInterface(mInputAreaContent);
if (inputAreaContent) {
inputAreaContent->BlurInnerTextBox();
}
}
nscoord
-nsDateTimeControlFrame::GetMinISize(nsRenderingContext* aRenderingContext)
+nsDateTimeControlFrame::GetMinISize(gfxContext* aRenderingContext)
{
nscoord result;
DISPLAY_MIN_WIDTH(this, result);
nsIFrame* kid = mFrames.FirstChild();
if (kid) { // display:none?
result = nsLayoutUtils::IntrinsicForContainer(aRenderingContext,
kid,
@@ -139,17 +139,17 @@ nsDateTimeControlFrame::GetMinISize(nsRe
} else {
result = 0;
}
return result;
}
nscoord
-nsDateTimeControlFrame::GetPrefISize(nsRenderingContext* aRenderingContext)
+nsDateTimeControlFrame::GetPrefISize(gfxContext* aRenderingContext)
{
nscoord result;
DISPLAY_PREF_WIDTH(this, result);
nsIFrame* kid = mFrames.FirstChild();
if (kid) { // display:none?
result = nsLayoutUtils::IntrinsicForContainer(aRenderingContext,
kid,
--- a/layout/forms/nsDateTimeControlFrame.h
+++ b/layout/forms/nsDateTimeControlFrame.h
@@ -51,19 +51,19 @@ public:
bool IsFrameOfType(uint32_t aFlags) const override
{
return nsContainerFrame::IsFrameOfType(aFlags &
~(nsIFrame::eReplaced | nsIFrame::eReplacedContainsBlock));
}
// Reflow
- nscoord GetMinISize(nsRenderingContext* aRenderingContext) override;
+ nscoord GetMinISize(gfxContext* aRenderingContext) override;
- nscoord GetPrefISize(nsRenderingContext* aRenderingContext) override;
+ nscoord GetPrefISize(gfxContext* aRenderingContext) override;
void Reflow(nsPresContext* aPresContext,
ReflowOutput& aDesiredSize,
const ReflowInput& aReflowState,
nsReflowStatus& aStatus) override;
// nsIAnonymousContentCreator
nsresult CreateAnonymousContent(nsTArray<ContentInfo>& aElements) override;
--- a/layout/forms/nsFieldSetFrame.cpp
+++ b/layout/forms/nsFieldSetFrame.cpp
@@ -1,27 +1,27 @@
/* -*- 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 "nsFieldSetFrame.h"
#include <algorithm>
+#include "gfxContext.h"
#include "mozilla/gfx/2D.h"
#include "mozilla/Likely.h"
#include "mozilla/Maybe.h"
#include "nsCSSAnonBoxes.h"
#include "nsCSSRendering.h"
#include "nsDisplayList.h"
#include "nsGkAtoms.h"
#include "nsIFrameInlines.h"
#include "nsLayoutUtils.h"
#include "nsLegendFrame.h"
-#include "nsRenderingContext.h"
#include "nsStyleConsts.h"
using namespace mozilla;
using namespace mozilla::gfx;
using namespace mozilla::layout;
nsContainerFrame*
NS_NewFieldSetFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
@@ -86,28 +86,28 @@ public:
MOZ_COUNT_CTOR(nsDisplayFieldSetBorder);
}
#ifdef NS_BUILD_REFCNT_LOGGING
virtual ~nsDisplayFieldSetBorder() {
MOZ_COUNT_DTOR(nsDisplayFieldSetBorder);
}
#endif
virtual void Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) override;
+ gfxContext* aCtx) override;
virtual nsDisplayItemGeometry* AllocateGeometry(nsDisplayListBuilder* aBuilder) override;
virtual void ComputeInvalidationRegion(nsDisplayListBuilder* aBuilder,
const nsDisplayItemGeometry* aGeometry,
nsRegion *aInvalidRegion) override;
virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder, bool* aSnap) override;
NS_DISPLAY_DECL_NAME("FieldSetBorder", TYPE_FIELDSET_BORDER_BACKGROUND)
};
void
nsDisplayFieldSetBorder::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx)
+ gfxContext* aCtx)
{
image::DrawResult result = static_cast<nsFieldSetFrame*>(mFrame)->
PaintBorder(aBuilder, *aCtx, ToReferenceFrame(), mVisibleRect);
nsDisplayItemGenericImageGeometry::UpdateDrawResult(this, result);
}
nsDisplayItemGeometry*
@@ -199,17 +199,17 @@ nsFieldSetFrame::BuildDisplayList(nsDisp
// which isn't really correct, but it's OK because the inner frame is
// anonymous and can't have its own border and background.
contentDisplayItems.MoveTo(aLists);
}
image::DrawResult
nsFieldSetFrame::PaintBorder(
nsDisplayListBuilder* aBuilder,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
nsPoint aPt,
const nsRect& aDirtyRect)
{
// If the border is smaller than the legend, move the border down
// to be centered on the legend. We call VisualBorderRectRelativeToSelf() to
// compute the border positioning.
// FIXME: This means border-radius clamping is incorrect; we should
// override nsIFrame::GetBorderRadii.
@@ -250,36 +250,34 @@ nsFieldSetFrame::PaintBorder(
*drawTarget),
true);
AppendRectToPath(pathBuilder,
NSRectToSnappedRect(legendRect, appUnitsPerDevPixel,
*drawTarget),
false);
RefPtr<Path> clipPath = pathBuilder->Finish();
- gfxContext* gfx = aRenderingContext.ThebesContext();
-
- gfx->Save();
- gfx->Clip(clipPath);
+ aRenderingContext.Save();
+ aRenderingContext.Clip(clipPath);
result &=
nsCSSRendering::PaintBorder(presContext, aRenderingContext, this,
aDirtyRect, rect, mStyleContext, borderFlags);
- gfx->Restore();
+ aRenderingContext.Restore();
} else {
result &=
nsCSSRendering::PaintBorder(presContext, aRenderingContext, this,
aDirtyRect, nsRect(aPt, mRect.Size()),
mStyleContext, borderFlags);
}
return result;
}
nscoord
-nsFieldSetFrame::GetIntrinsicISize(nsRenderingContext* aRenderingContext,
+nsFieldSetFrame::GetIntrinsicISize(gfxContext* aRenderingContext,
nsLayoutUtils::IntrinsicISizeType aType)
{
nscoord legendWidth = 0;
nscoord contentWidth = 0;
if (nsIFrame* legend = GetLegend()) {
legendWidth =
nsLayoutUtils::IntrinsicForContainer(aRenderingContext, legend, aType);
}
@@ -293,27 +291,27 @@ nsFieldSetFrame::GetIntrinsicISize(nsRen
nsLayoutUtils::IGNORE_PADDING);
}
return std::max(legendWidth, contentWidth);
}
nscoord
-nsFieldSetFrame::GetMinISize(nsRenderingContext* aRenderingContext)
+nsFieldSetFrame::GetMinISize(gfxContext* aRenderingContext)
{
nscoord result = 0;
DISPLAY_MIN_WIDTH(this, result);
result = GetIntrinsicISize(aRenderingContext, nsLayoutUtils::MIN_ISIZE);
return result;
}
nscoord
-nsFieldSetFrame::GetPrefISize(nsRenderingContext* aRenderingContext)
+nsFieldSetFrame::GetPrefISize(gfxContext* aRenderingContext)
{
nscoord result = 0;
DISPLAY_PREF_WIDTH(this, result);
result = GetIntrinsicISize(aRenderingContext, nsLayoutUtils::PREF_ISIZE);
return result;
}
--- a/layout/forms/nsFieldSetFrame.h
+++ b/layout/forms/nsFieldSetFrame.h
@@ -15,20 +15,20 @@ class nsFieldSetFrame final : public nsC
typedef mozilla::image::DrawResult DrawResult;
public:
NS_DECL_FRAMEARENA_HELPERS(nsFieldSetFrame)
explicit nsFieldSetFrame(nsStyleContext* aContext);
nscoord
- GetIntrinsicISize(nsRenderingContext* aRenderingContext,
+ GetIntrinsicISize(gfxContext* aRenderingContext,
nsLayoutUtils::IntrinsicISizeType);
- virtual nscoord GetMinISize(nsRenderingContext* aRenderingContext) override;
- virtual nscoord GetPrefISize(nsRenderingContext* aRenderingContext) override;
+ virtual nscoord GetMinISize(gfxContext* aRenderingContext) override;
+ virtual nscoord GetPrefISize(gfxContext* aRenderingContext) override;
/**
* The area to paint box-shadows around. It's the border rect except
* when there's a <legend> we offset the y-position to the center of it.
*/
virtual nsRect VisualBorderRectRelativeToSelf() const override;
virtual void Reflow(nsPresContext* aPresContext,
@@ -43,17 +43,17 @@ public:
BaselineSharingGroup aBaselineGroup,
nscoord* aBaseline) const override;
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) override;
DrawResult PaintBorder(nsDisplayListBuilder* aBuilder,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
nsPoint aPt, const nsRect& aDirtyRect);
#ifdef DEBUG
virtual void SetInitialChildList(ChildListID aListID,
nsFrameList& aChildList) override;
virtual void AppendFrames(ChildListID aListID,
nsFrameList& aFrameList) override;
virtual void InsertFrames(ChildListID aListID,
--- a/layout/forms/nsFileControlFrame.cpp
+++ b/layout/forms/nsFileControlFrame.cpp
@@ -417,17 +417,17 @@ nsFileControlFrame::DnDListener::CanDrop
uint32_t listLength = 0;
if (fileList) {
fileList->GetLength(&listLength);
}
return listLength <= 1 || aSupportsMultiple;
}
nscoord
-nsFileControlFrame::GetMinISize(nsRenderingContext *aRenderingContext)
+nsFileControlFrame::GetMinISize(gfxContext *aRenderingContext)
{
nscoord result;
DISPLAY_MIN_WIDTH(this, result);
// Our min width is our pref width
result = GetPrefISize(aRenderingContext);
return result;
}
--- a/layout/forms/nsFileControlFrame.h
+++ b/layout/forms/nsFileControlFrame.h
@@ -38,17 +38,17 @@ public:
NS_DECL_QUERYFRAME
NS_DECL_FRAMEARENA_HELPERS(nsFileControlFrame)
// nsIFormControlFrame
virtual nsresult SetFormProperty(nsIAtom* aName, const nsAString& aValue) override;
virtual void SetFocus(bool aOn, bool aRepaint) override;
- virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override;
+ virtual nscoord GetMinISize(gfxContext *aRenderingContext) override;
virtual void DestroyFrom(nsIFrame* aDestructRoot) override;
#ifdef DEBUG_FRAME_DUMP
virtual nsresult GetFrameName(nsAString& aResult) const override;
#endif
virtual nsresult AttributeChanged(int32_t aNameSpaceID,
--- a/layout/forms/nsFormControlFrame.cpp
+++ b/layout/forms/nsFormControlFrame.cpp
@@ -35,44 +35,44 @@ nsFormControlFrame::DestroyFrom(nsIFrame
nsAtomicContainerFrame::DestroyFrom(aDestructRoot);
}
NS_QUERYFRAME_HEAD(nsFormControlFrame)
NS_QUERYFRAME_ENTRY(nsIFormControlFrame)
NS_QUERYFRAME_TAIL_INHERITING(nsAtomicContainerFrame)
/* virtual */ nscoord
-nsFormControlFrame::GetMinISize(nsRenderingContext *aRenderingContext)
+nsFormControlFrame::GetMinISize(gfxContext *aRenderingContext)
{
nscoord result;
DISPLAY_MIN_WIDTH(this, result);
#if !defined(MOZ_WIDGET_ANDROID)
result = StyleDisplay()->mAppearance == NS_THEME_NONE ? 0 : DefaultSize();
#else
result = DefaultSize();
#endif
return result;
}
/* virtual */ nscoord
-nsFormControlFrame::GetPrefISize(nsRenderingContext *aRenderingContext)
+nsFormControlFrame::GetPrefISize(gfxContext *aRenderingContext)
{
nscoord result;
DISPLAY_PREF_WIDTH(this, result);
#if !defined(MOZ_WIDGET_ANDROID)
result = StyleDisplay()->mAppearance == NS_THEME_NONE ? 0 : DefaultSize();
#else
result = DefaultSize();
#endif
return result;
}
/* virtual */
LogicalSize
-nsFormControlFrame::ComputeAutoSize(nsRenderingContext* aRC,
+nsFormControlFrame::ComputeAutoSize(gfxContext* aRC,
WritingMode aWM,
const LogicalSize& aCBSize,
nscoord aAvailableISize,
const LogicalSize& aMargin,
const LogicalSize& aBorder,
const LogicalSize& aPadding,
ComputeSizeFlags aFlags)
{
--- a/layout/forms/nsFormControlFrame.h
+++ b/layout/forms/nsFormControlFrame.h
@@ -43,24 +43,24 @@ public:
DO_GLOBAL_REFLOW_COUNT_DSP("nsFormControlFrame");
DisplayBorderBackgroundOutline(aBuilder, aLists);
}
/**
* Both GetMinISize and GetPrefISize will return whatever GetIntrinsicISize
* returns.
*/
- virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override;
- virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override;
+ virtual nscoord GetMinISize(gfxContext *aRenderingContext) override;
+ virtual nscoord GetPrefISize(gfxContext *aRenderingContext) override;
/**
* Our auto size is just intrinsic width and intrinsic height.
*/
virtual mozilla::LogicalSize
- ComputeAutoSize(nsRenderingContext* aRenderingContext,
+ ComputeAutoSize(gfxContext* aRenderingContext,
mozilla::WritingMode aWM,
const mozilla::LogicalSize& aCBSize,
nscoord aAvailableISize,
const mozilla::LogicalSize& aMargin,
const mozilla::LogicalSize& aBorder,
const mozilla::LogicalSize& aPadding,
ComputeSizeFlags aFlags) override;
--- a/layout/forms/nsGfxCheckboxControlFrame.cpp
+++ b/layout/forms/nsGfxCheckboxControlFrame.cpp
@@ -1,21 +1,21 @@
/* -*- 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 "nsGfxCheckboxControlFrame.h"
+#include "gfxContext.h"
#include "gfxUtils.h"
#include "mozilla/gfx/2D.h"
#include "nsIContent.h"
#include "nsCOMPtr.h"
#include "nsLayoutUtils.h"
-#include "nsRenderingContext.h"
#include "nsIDOMHTMLInputElement.h"
#include "nsDisplayList.h"
#include <algorithm>
using namespace mozilla;
using namespace mozilla::gfx;
#ifdef MOZ_WIDGET_ANDROID
--- a/layout/forms/nsGfxRadioControlFrame.cpp
+++ b/layout/forms/nsGfxRadioControlFrame.cpp
@@ -1,21 +1,21 @@
/* -*- 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 "nsGfxRadioControlFrame.h"
#include "gfx2DGlue.h"
+#include "gfxContext.h"
#include "gfxUtils.h"
#include "mozilla/gfx/2D.h"
#include "mozilla/gfx/PathHelpers.h"
#include "nsLayoutUtils.h"
-#include "nsRenderingContext.h"
#include "nsDisplayList.h"
using namespace mozilla;
using namespace mozilla::gfx;
nsIFrame*
NS_NewGfxRadioControlFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
{
--- a/layout/forms/nsHTMLButtonControlFrame.cpp
+++ b/layout/forms/nsHTMLButtonControlFrame.cpp
@@ -137,31 +137,31 @@ nsHTMLButtonControlFrame::BuildDisplayLi
DisplayOutline(aBuilder, aLists);
// to draw border when selected in editor
DisplaySelectionOverlay(aBuilder, aLists.Content());
}
nscoord
-nsHTMLButtonControlFrame::GetMinISize(nsRenderingContext* aRenderingContext)
+nsHTMLButtonControlFrame::GetMinISize(gfxContext* aRenderingContext)
{
nscoord result;
DISPLAY_MIN_WIDTH(this, result);
nsIFrame* kid = mFrames.FirstChild();
result = nsLayoutUtils::IntrinsicForContainer(aRenderingContext,
kid,
nsLayoutUtils::MIN_ISIZE);
return result;
}
nscoord
-nsHTMLButtonControlFrame::GetPrefISize(nsRenderingContext* aRenderingContext)
+nsHTMLButtonControlFrame::GetPrefISize(gfxContext* aRenderingContext)
{
nscoord result;
DISPLAY_PREF_WIDTH(this, result);
nsIFrame* kid = mFrames.FirstChild();
result = nsLayoutUtils::IntrinsicForContainer(aRenderingContext,
kid,
nsLayoutUtils::PREF_ISIZE);
--- a/layout/forms/nsHTMLButtonControlFrame.h
+++ b/layout/forms/nsHTMLButtonControlFrame.h
@@ -6,17 +6,17 @@
#ifndef nsHTMLButtonControlFrame_h___
#define nsHTMLButtonControlFrame_h___
#include "mozilla/Attributes.h"
#include "nsContainerFrame.h"
#include "nsIFormControlFrame.h"
#include "nsButtonFrameRenderer.h"
-class nsRenderingContext;
+class gfxContext;
class nsPresContext;
class nsHTMLButtonControlFrame : public nsContainerFrame,
public nsIFormControlFrame
{
public:
explicit nsHTMLButtonControlFrame(nsStyleContext* aContext)
: nsHTMLButtonControlFrame(aContext, kClassID)
@@ -28,19 +28,19 @@ public:
NS_DECL_QUERYFRAME
NS_DECL_FRAMEARENA_HELPERS(nsHTMLButtonControlFrame)
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) override;
- virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override;
+ virtual nscoord GetMinISize(gfxContext *aRenderingContext) override;
- virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override;
+ virtual nscoord GetPrefISize(gfxContext *aRenderingContext) override;
virtual void Reflow(nsPresContext* aPresContext,
ReflowOutput& aDesiredSize,
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus) override;
bool GetVerticalAlignBaseline(mozilla::WritingMode aWM,
nscoord* aBaseline) const override;
--- a/layout/forms/nsListControlFrame.cpp
+++ b/layout/forms/nsListControlFrame.cpp
@@ -318,17 +318,17 @@ nsListControlFrame::CalcBSizeOfARow()
float inflation = nsLayoutUtils::FontSizeInflationFor(this);
blockSizeOfARow = CalcFallbackRowBSize(inflation);
}
return blockSizeOfARow;
}
nscoord
-nsListControlFrame::GetPrefISize(nsRenderingContext *aRenderingContext)
+nsListControlFrame::GetPrefISize(gfxContext *aRenderingContext)
{
nscoord result;
DISPLAY_PREF_WIDTH(this, result);
// Always add scrollbar inline sizes to the pref-inline-size of the
// scrolled content. Combobox frames depend on this happening in the
// dropdown, and standalone listboxes are overflow:scroll so they need
// it too.
@@ -336,17 +336,17 @@ nsListControlFrame::GetPrefISize(nsRende
result = GetScrolledFrame()->GetPrefISize(aRenderingContext);
LogicalMargin scrollbarSize(wm, GetDesiredScrollbarSizes(PresContext(),
aRenderingContext));
result = NSCoordSaturatingAdd(result, scrollbarSize.IStartEnd(wm));
return result;
}
nscoord
-nsListControlFrame::GetMinISize(nsRenderingContext *aRenderingContext)
+nsListControlFrame::GetMinISize(gfxContext *aRenderingContext)
{
nscoord result;
DISPLAY_MIN_WIDTH(this, result);
// Always add scrollbar inline sizes to the min-inline-size of the
// scrolled content. Combobox frames depend on this happening in the
// dropdown, and standalone listboxes are overflow:scroll so they need
// it too.
--- a/layout/forms/nsListControlFrame.h
+++ b/layout/forms/nsListControlFrame.h
@@ -60,18 +60,18 @@ public:
// nsIFrame
virtual nsresult HandleEvent(nsPresContext* aPresContext,
mozilla::WidgetGUIEvent* aEvent,
nsEventStatus* aEventStatus) override;
virtual void SetInitialChildList(ChildListID aListID,
nsFrameList& aChildList) override;
- virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override;
- virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override;
+ virtual nscoord GetPrefISize(gfxContext *aRenderingContext) override;
+ virtual nscoord GetMinISize(gfxContext *aRenderingContext) override;
virtual void Reflow(nsPresContext* aCX,
ReflowOutput& aDesiredSize,
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus) override;
virtual void Init(nsIContent* aContent,
nsContainerFrame* aParent,
--- a/layout/forms/nsMeterFrame.cpp
+++ b/layout/forms/nsMeterFrame.cpp
@@ -205,17 +205,17 @@ nsMeterFrame::AttributeChanged(int32_t
InvalidateFrame();
}
return nsContainerFrame::AttributeChanged(aNameSpaceID, aAttribute,
aModType);
}
LogicalSize
-nsMeterFrame::ComputeAutoSize(nsRenderingContext* aRenderingContext,
+nsMeterFrame::ComputeAutoSize(gfxContext* aRenderingContext,
WritingMode aWM,
const LogicalSize& aCBSize,
nscoord aAvailableISize,
const LogicalSize& aMargin,
const LogicalSize& aBorder,
const LogicalSize& aPadding,
ComputeSizeFlags aFlags)
{
@@ -231,33 +231,33 @@ nsMeterFrame::ComputeAutoSize(nsRenderin
} else {
autoSize.BSize(wm) *= 5; // 5em
}
return autoSize.ConvertTo(aWM, wm);
}
nscoord
-nsMeterFrame::GetMinISize(nsRenderingContext *aRenderingContext)
+nsMeterFrame::GetMinISize(gfxContext *aRenderingContext)
{
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
}
return minISize;
}
nscoord
-nsMeterFrame::GetPrefISize(nsRenderingContext *aRenderingContext)
+nsMeterFrame::GetPrefISize(gfxContext *aRenderingContext)
{
return GetMinISize(aRenderingContext);
}
bool
nsMeterFrame::ShouldUseNativeStyle() const
{
nsIFrame* barFrame = mBarDiv->GetPrimaryFrame();
--- a/layout/forms/nsMeterFrame.h
+++ b/layout/forms/nsMeterFrame.h
@@ -43,27 +43,27 @@ public:
virtual void AppendAnonymousContentTo(nsTArray<nsIContent*>& aElements,
uint32_t aFilter) override;
virtual nsresult AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType) override;
virtual mozilla::LogicalSize
- ComputeAutoSize(nsRenderingContext* aRenderingContext,
+ ComputeAutoSize(gfxContext* aRenderingContext,
mozilla::WritingMode aWM,
const mozilla::LogicalSize& aCBSize,
nscoord aAvailableISize,
const mozilla::LogicalSize& aMargin,
const mozilla::LogicalSize& aBorder,
const mozilla::LogicalSize& aPadding,
ComputeSizeFlags aFlags) override;
- virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override;
- virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override;
+ virtual nscoord GetMinISize(gfxContext *aRenderingContext) override;
+ virtual nscoord GetPrefISize(gfxContext *aRenderingContext) override;
virtual bool IsFrameOfType(uint32_t aFlags) const override
{
return nsContainerFrame::IsFrameOfType(aFlags &
~(nsIFrame::eReplaced | nsIFrame::eReplacedContainsBlock));
}
/**
--- a/layout/forms/nsNumberControlFrame.cpp
+++ b/layout/forms/nsNumberControlFrame.cpp
@@ -62,17 +62,17 @@ nsNumberControlFrame::DestroyFrom(nsIFra
"nsNumberControlFrame should not have continuations; if it does we "
"need to call RegUnregAccessKey only for the first");
nsFormControlFrame::RegUnRegAccessKey(static_cast<nsIFrame*>(this), false);
nsContentUtils::DestroyAnonymousContent(&mOuterWrapper);
nsContainerFrame::DestroyFrom(aDestructRoot);
}
nscoord
-nsNumberControlFrame::GetMinISize(nsRenderingContext* aRenderingContext)
+nsNumberControlFrame::GetMinISize(gfxContext* aRenderingContext)
{
nscoord result;
DISPLAY_MIN_WIDTH(this, result);
nsIFrame* kid = mFrames.FirstChild();
if (kid) { // display:none?
result = nsLayoutUtils::IntrinsicForContainer(aRenderingContext,
kid,
@@ -80,17 +80,17 @@ nsNumberControlFrame::GetMinISize(nsRend
} else {
result = 0;
}
return result;
}
nscoord
-nsNumberControlFrame::GetPrefISize(nsRenderingContext* aRenderingContext)
+nsNumberControlFrame::GetPrefISize(gfxContext* aRenderingContext)
{
nscoord result;
DISPLAY_PREF_WIDTH(this, result);
nsIFrame* kid = mFrames.FirstChild();
if (kid) { // display:none?
result = nsLayoutUtils::IntrinsicForContainer(aRenderingContext,
kid,
--- a/layout/forms/nsNumberControlFrame.h
+++ b/layout/forms/nsNumberControlFrame.h
@@ -48,19 +48,19 @@ public:
virtual void DestroyFrom(nsIFrame* aDestructRoot) override;
virtual void ContentStatesChanged(mozilla::EventStates aStates) override;
#ifdef ACCESSIBILITY
virtual mozilla::a11y::AccType AccessibleType() override;
#endif
- virtual nscoord GetMinISize(nsRenderingContext* aRenderingContext) override;
+ virtual nscoord GetMinISize(gfxContext* aRenderingContext) override;
- virtual nscoord GetPrefISize(nsRenderingContext* aRenderingContext) override;
+ virtual nscoord GetPrefISize(gfxContext* aRenderingContext) override;
virtual void Reflow(nsPresContext* aPresContext,
ReflowOutput& aDesiredSize,
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus) override;
virtual nsresult AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
--- a/layout/forms/nsProgressFrame.cpp
+++ b/layout/forms/nsProgressFrame.cpp
@@ -219,17 +219,17 @@ nsProgressFrame::AttributeChanged(int32_
}
InvalidateFrame();
}
return nsContainerFrame::AttributeChanged(aNameSpaceID, aAttribute, aModType);
}
LogicalSize
-nsProgressFrame::ComputeAutoSize(nsRenderingContext* aRenderingContext,
+nsProgressFrame::ComputeAutoSize(gfxContext* aRenderingContext,
WritingMode aWM,
const LogicalSize& aCBSize,
nscoord aAvailableISize,
const LogicalSize& aMargin,
const LogicalSize& aBorder,
const LogicalSize& aPadding,
ComputeSizeFlags aFlags)
{
@@ -244,33 +244,33 @@ nsProgressFrame::ComputeAutoSize(nsRende
} else {
autoSize.BSize(wm) *= 10; // 10em
}
return autoSize.ConvertTo(aWM, wm);
}
nscoord
-nsProgressFrame::GetMinISize(nsRenderingContext *aRenderingContext)
+nsProgressFrame::GetMinISize(gfxContext *aRenderingContext)
{
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
}
return minISize;
}
nscoord
-nsProgressFrame::GetPrefISize(nsRenderingContext *aRenderingContext)
+nsProgressFrame::GetPrefISize(gfxContext *aRenderingContext)
{
return GetMinISize(aRenderingContext);
}
bool
nsProgressFrame::ShouldUseNativeStyle() const
{
nsIFrame* barFrame = PrincipalChildList().FirstChild();
--- a/layout/forms/nsProgressFrame.h
+++ b/layout/forms/nsProgressFrame.h
@@ -51,27 +51,27 @@ public:
virtual void AppendAnonymousContentTo(nsTArray<nsIContent*>& aElements,
uint32_t aFilter) override;
virtual nsresult AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType) override;
virtual mozilla::LogicalSize
- ComputeAutoSize(nsRenderingContext* aRenderingContext,
+ ComputeAutoSize(gfxContext* aRenderingContext,
mozilla::WritingMode aWM,
const mozilla::LogicalSize& aCBSize,
nscoord aAvailableISize,
const mozilla::LogicalSize& aMargin,
const mozilla::LogicalSize& aBorder,
const mozilla::LogicalSize& aPadding,
ComputeSizeFlags aFlags) override;
- virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override;
- virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override;
+ virtual nscoord GetMinISize(gfxContext *aRenderingContext) override;
+ virtual nscoord GetPrefISize(gfxContext *aRenderingContext) override;
virtual bool IsFrameOfType(uint32_t aFlags) const override
{
return nsContainerFrame::IsFrameOfType(aFlags &
~(nsIFrame::eReplaced | nsIFrame::eReplacedContainsBlock));
}
/**
--- a/layout/forms/nsRangeFrame.cpp
+++ b/layout/forms/nsRangeFrame.cpp
@@ -3,31 +3,31 @@
* 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 "nsRangeFrame.h"
#include "mozilla/EventStates.h"
#include "mozilla/TouchEvents.h"
+#include "gfxContext.h"
#include "nsContentCreatorFunctions.h"
#include "nsContentList.h"
#include "nsContentUtils.h"
#include "nsCSSPseudoElements.h"
#include "nsCSSRendering.h"
#include "nsFormControlFrame.h"
#include "nsIContent.h"
#include "nsIDocument.h"
#include "nsNameSpaceManager.h"
#include "nsIPresShell.h"
#include "nsGkAtoms.h"
#include "mozilla/dom/HTMLInputElement.h"
#include "nsPresContext.h"
#include "nsNodeInfoManager.h"
-#include "nsRenderingContext.h"
#include "mozilla/dom/Element.h"
#include "mozilla/StyleSetHandle.h"
#include "mozilla/StyleSetHandleInlines.h"
#include "nsThemeConstants.h"
#ifdef ACCESSIBILITY
#include "nsAccessibilityService.h"
#endif
@@ -183,17 +183,17 @@ public:
}
#endif
nsDisplayItemGeometry* AllocateGeometry(nsDisplayListBuilder* aBuilder) override;
void ComputeInvalidationRegion(nsDisplayListBuilder* aBuilder,
const nsDisplayItemGeometry* aGeometry,
nsRegion *aInvalidRegion) override;
virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder, bool* aSnap) override;
- virtual void Paint(nsDisplayListBuilder* aBuilder, nsRenderingContext* aCtx) override;
+ virtual void Paint(nsDisplayListBuilder* aBuilder, gfxContext* aCtx) override;
NS_DISPLAY_DECL_NAME("RangeFocusRing", TYPE_RANGE_FOCUS_RING)
};
nsDisplayItemGeometry*
nsDisplayRangeFocusRing::AllocateGeometry(nsDisplayListBuilder* aBuilder)
{
return new nsDisplayItemGenericImageGeometry(this, aBuilder);
}
@@ -229,17 +229,17 @@ nsDisplayRangeFocusRing::GetBounds(nsDis
MOZ_ASSERT(styleContext, "We only exist if mOuterFocusStyle is non-null");
rect.Inflate(styleContext->StyleBorder()->GetComputedBorder());
return rect;
}
void
nsDisplayRangeFocusRing::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx)
+ gfxContext* aCtx)
{
bool unused;
nsStyleContext* styleContext =
static_cast<nsRangeFrame*>(mFrame)->mOuterFocusStyle;
MOZ_ASSERT(styleContext, "We only exist if mOuterFocusStyle is non-null");
PaintBorderFlags flags = aBuilder->ShouldSyncDecodeImages()
? PaintBorderFlags::SYNC_DECODE_IMAGES
@@ -763,17 +763,17 @@ nsRangeFrame::AttributeChanged(int32_t
NS_FRAME_IS_DIRTY);
}
}
return nsContainerFrame::AttributeChanged(aNameSpaceID, aAttribute, aModType);
}
LogicalSize
-nsRangeFrame::ComputeAutoSize(nsRenderingContext* aRenderingContext,
+nsRangeFrame::ComputeAutoSize(gfxContext* aRenderingContext,
WritingMode aWM,
const LogicalSize& aCBSize,
nscoord aAvailableISize,
const LogicalSize& aMargin,
const LogicalSize& aBorder,
const LogicalSize& aPadding,
ComputeSizeFlags aFlags)
{
@@ -798,26 +798,26 @@ nsRangeFrame::ComputeAutoSize(nsRenderin
autoSize.ISize(wm) = IsThemed() ? 0 : oneEm;
autoSize.BSize(wm) = LONG_SIDE_TO_SHORT_SIDE_RATIO * oneEm;
}
return autoSize.ConvertTo(aWM, wm);
}
nscoord
-nsRangeFrame::GetMinISize(nsRenderingContext *aRenderingContext)
+nsRangeFrame::GetMinISize(gfxContext *aRenderingContext)
{
// nsFrame::ComputeSize calls GetMinimumWidgetSize to prevent us from being
// given too small a size when we're natively themed. If we aren't native
// themed, we don't mind how small we're sized.
return nscoord(0);
}
nscoord
-nsRangeFrame::GetPrefISize(nsRenderingContext *aRenderingContext)
+nsRangeFrame::GetPrefISize(gfxContext *aRenderingContext)
{
bool isInline = IsInlineOriented();
if (!isInline && IsThemed()) {
// nsFrame::ComputeSize calls GetMinimumWidgetSize to prevent us from being
// given too small a size when we're natively themed. We return zero and
// depend on that correction to get our "natural" width when we're a
// vertical slider.
--- a/layout/forms/nsRangeFrame.h
+++ b/layout/forms/nsRangeFrame.h
@@ -65,27 +65,27 @@ public:
virtual void AppendAnonymousContentTo(nsTArray<nsIContent*>& aElements,
uint32_t aFilter) override;
virtual nsresult AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType) override;
virtual mozilla::LogicalSize
- ComputeAutoSize(nsRenderingContext* aRenderingContext,
+ ComputeAutoSize(gfxContext* aRenderingContext,
mozilla::WritingMode aWM,
const mozilla::LogicalSize& aCBSize,
nscoord aAvailableISize,
const mozilla::LogicalSize& aMargin,
const mozilla::LogicalSize& aBorder,
const mozilla::LogicalSize& aPadding,
ComputeSizeFlags aFlags) override;
- virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override;
- virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override;
+ virtual nscoord GetMinISize(gfxContext *aRenderingContext) override;
+ virtual nscoord GetPrefISize(gfxContext *aRenderingContext) override;
virtual bool IsFrameOfType(uint32_t aFlags) const override
{
return nsContainerFrame::IsFrameOfType(aFlags &
~(nsIFrame::eReplaced | nsIFrame::eReplacedContainsBlock));
}
nsStyleContext* GetAdditionalStyleContext(int32_t aIndex) const override;
--- a/layout/forms/nsSelectsAreaFrame.cpp
+++ b/layout/forms/nsSelectsAreaFrame.cpp
@@ -110,17 +110,17 @@ public:
*aSnap = false;
// override bounds because the list item focus ring may extend outside
// the nsSelectsAreaFrame
nsListControlFrame* listFrame = GetEnclosingListFrame(Frame());
return listFrame->GetVisualOverflowRectRelativeToSelf() +
listFrame->GetOffsetToCrossDoc(ReferenceFrame());
}
virtual void Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) override {
+ gfxContext* aCtx) override {
nsListControlFrame* listFrame = GetEnclosingListFrame(Frame());
// listFrame must be non-null or we wouldn't get called.
listFrame->PaintFocus(aCtx->GetDrawTarget(),
aBuilder->ToReferenceFrame(listFrame));
}
NS_DISPLAY_DECL_NAME("ListFocus", TYPE_LIST_FOCUS)
};
--- a/layout/forms/nsTextControlFrame.cpp
+++ b/layout/forms/nsTextControlFrame.cpp
@@ -1,31 +1,31 @@
/* -*- 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 "mozilla/DebugOnly.h"
+#include "gfxContext.h"
#include "nsCOMPtr.h"
#include "nsFontMetrics.h"
#include "nsTextControlFrame.h"
#include "nsIPlaintextEditor.h"
#include "nsCaret.h"
#include "nsCSSPseudoElements.h"
#include "nsGenericHTMLElement.h"
#include "nsIEditor.h"
#include "nsTextFragment.h"
#include "nsIDOMHTMLTextAreaElement.h"
#include "nsNameSpaceManager.h"
#include "nsFormControlFrame.h" //for registering accesskeys
#include "nsIContent.h"
#include "nsPresContext.h"
-#include "nsRenderingContext.h"
#include "nsGkAtoms.h"
#include "nsLayoutUtils.h"
#include "nsIDOMElement.h"
#include "nsIDOMHTMLElement.h"
#include "nsIPresShell.h"
#include <algorithm>
#include "nsIDOMNodeList.h" //for selection setting helper func
@@ -133,17 +133,17 @@ nsTextControlFrame::DestroyFrom(nsIFrame
txtCtrl->UnbindFromFrame(this);
nsFormControlFrame::RegUnRegAccessKey(static_cast<nsIFrame*>(this), false);
nsContainerFrame::DestroyFrom(aDestructRoot);
}
LogicalSize
-nsTextControlFrame::CalcIntrinsicSize(nsRenderingContext* aRenderingContext,
+nsTextControlFrame::CalcIntrinsicSize(gfxContext* aRenderingContext,
WritingMode aWM,
float aFontSizeInflation) const
{
LogicalSize intrinsicSize(aWM);
// Get leading and the Average/MaxAdvance char width
nscoord lineHeight = 0;
nscoord charWidth = 0;
nscoord charMaxAdvance = 0;
@@ -426,38 +426,38 @@ nsTextControlFrame::AppendAnonymousConte
nsIContent* preview = txtCtrl->GetPreviewNode();
if (preview) {
aElements.AppendElement(preview);
}
}
nscoord
-nsTextControlFrame::GetPrefISize(nsRenderingContext* aRenderingContext)
+nsTextControlFrame::GetPrefISize(gfxContext* aRenderingContext)
{
nscoord result = 0;
DISPLAY_PREF_WIDTH(this, result);
float inflation = nsLayoutUtils::FontSizeInflationFor(this);
WritingMode wm = GetWritingMode();
result = CalcIntrinsicSize(aRenderingContext, wm, inflation).ISize(wm);
return result;
}
nscoord
-nsTextControlFrame::GetMinISize(nsRenderingContext* aRenderingContext)
+nsTextControlFrame::GetMinISize(gfxContext* aRenderingContext)
{
// Our min width is just our preferred width if we have auto width.
nscoord result;
DISPLAY_MIN_WIDTH(this, result);
result = GetPrefISize(aRenderingContext);
return result;
}
LogicalSize
-nsTextControlFrame::ComputeAutoSize(nsRenderingContext* aRenderingContext,
+nsTextControlFrame::ComputeAutoSize(gfxContext* aRenderingContext,
WritingMode aWM,
const LogicalSize& aCBSize,
nscoord aAvailableISize,
const LogicalSize& aMargin,
const LogicalSize& aBorder,
const LogicalSize& aPadding,
ComputeSizeFlags aFlags)
{
--- a/layout/forms/nsTextControlFrame.h
+++ b/layout/forms/nsTextControlFrame.h
@@ -39,21 +39,21 @@ public:
virtual ~nsTextControlFrame();
virtual void DestroyFrom(nsIFrame* aDestructRoot) override;
virtual nsIScrollableFrame* GetScrollTargetFrame() override {
return do_QueryFrame(PrincipalChildList().FirstChild());
}
- virtual nscoord GetMinISize(nsRenderingContext* aRenderingContext) override;
- virtual nscoord GetPrefISize(nsRenderingContext* aRenderingContext) override;
+ virtual nscoord GetMinISize(gfxContext* aRenderingContext) override;
+ virtual nscoord GetPrefISize(gfxContext* aRenderingContext) override;
virtual mozilla::LogicalSize
- ComputeAutoSize(nsRenderingContext* aRenderingContext,
+ ComputeAutoSize(gfxContext* aRenderingContext,
mozilla::WritingMode aWM,
const mozilla::LogicalSize& aCBSize,
nscoord aAvailableISize,
const mozilla::LogicalSize& aMargin,
const mozilla::LogicalSize& aBorder,
const mozilla::LogicalSize& aPadding,
ComputeSizeFlags aFlags) override;
@@ -295,17 +295,17 @@ protected:
* We call this when we are being destroyed or removed from the PFM.
* @param aPresContext the current pres context
*/
void PreDestroy();
// Compute our intrinsic size. This does not include any borders, paddings,
// etc. Just the size of our actual area for the text (and the scrollbars,
// for <textarea>).
- mozilla::LogicalSize CalcIntrinsicSize(nsRenderingContext* aRenderingContext,
+ mozilla::LogicalSize CalcIntrinsicSize(gfxContext* aRenderingContext,
mozilla::WritingMode aWM,
float aFontSizeInflation) const;
nsresult ScrollSelectionIntoView() override;
private:
//helper methods
nsresult SetSelectionInternal(nsIDOMNode *aStartNode, uint32_t aStartOffset,
--- a/layout/generic/BRFrame.cpp
+++ b/layout/generic/BRFrame.cpp
@@ -1,24 +1,24 @@
/* -*- 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/. */
/* rendering object for HTML <br> elements */
+#include "gfxContext.h"
#include "nsCOMPtr.h"
#include "nsContainerFrame.h"
#include "nsFontMetrics.h"
#include "nsFrame.h"
#include "nsPresContext.h"
#include "nsLineLayout.h"
#include "nsStyleConsts.h"
#include "nsGkAtoms.h"
-#include "nsRenderingContext.h"
#include "nsLayoutUtils.h"
//FOR SELECTION
#include "nsIContent.h"
//END INCLUDES FOR SELECTION
using namespace mozilla;
@@ -39,22 +39,22 @@ public:
virtual FrameSearchResult PeekOffsetWord(bool aForward, bool aWordSelectEatSpace,
bool aIsKeyboardSelect, int32_t* aOffset,
PeekWordState* aState) override;
virtual void Reflow(nsPresContext* aPresContext,
ReflowOutput& aDesiredSize,
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus) override;
- virtual void AddInlineMinISize(nsRenderingContext *aRenderingContext,
+ virtual void AddInlineMinISize(gfxContext *aRenderingContext,
InlineMinISizeData *aData) override;
- virtual void AddInlinePrefISize(nsRenderingContext *aRenderingContext,
+ virtual void AddInlinePrefISize(gfxContext *aRenderingContext,
InlinePrefISizeData *aData) override;
- virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override;
- virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override;
+ virtual nscoord GetMinISize(gfxContext *aRenderingContext) override;
+ virtual nscoord GetPrefISize(gfxContext *aRenderingContext) override;
virtual nscoord GetLogicalBaseline(mozilla::WritingMode aWritingMode) const override;
virtual bool IsFrameOfType(uint32_t aFlags) const override
{
return nsFrame::IsFrameOfType(aFlags & ~(nsIFrame::eReplaced |
nsIFrame::eLineParticipant));
}
@@ -170,45 +170,45 @@ BRFrame::Reflow(nsPresContext* aPresCont
aMetrics.SetOverflowAreasToDesiredBounds();
mAscent = aMetrics.BlockStartAscent();
NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aMetrics);
}
/* virtual */ void
-BRFrame::AddInlineMinISize(nsRenderingContext *aRenderingContext,
+BRFrame::AddInlineMinISize(gfxContext *aRenderingContext,
nsIFrame::InlineMinISizeData *aData)
{
if (!GetParent()->StyleContext()->ShouldSuppressLineBreak()) {
aData->ForceBreak();
}
}
/* virtual */ void
-BRFrame::AddInlinePrefISize(nsRenderingContext *aRenderingContext,
+BRFrame::AddInlinePrefISize(gfxContext *aRenderingContext,
nsIFrame::InlinePrefISizeData *aData)
{
if (!GetParent()->StyleContext()->ShouldSuppressLineBreak()) {
// Match the 1 appunit width assigned in the Reflow method above
aData->mCurrentLine += 1;
aData->ForceBreak();
}
}
/* virtual */ nscoord
-BRFrame::GetMinISize(nsRenderingContext *aRenderingContext)
+BRFrame::GetMinISize(gfxContext *aRenderingContext)
{
nscoord result = 0;
DISPLAY_MIN_WIDTH(this, result);
return result;
}
/* virtual */ nscoord
-BRFrame::GetPrefISize(nsRenderingContext *aRenderingContext)
+BRFrame::GetPrefISize(gfxContext *aRenderingContext)
{
nscoord result = 0;
DISPLAY_PREF_WIDTH(this, result);
return result;
}
nscoord
BRFrame::GetLogicalBaseline(mozilla::WritingMode aWritingMode) const
--- a/layout/generic/BlockReflowInput.cpp
+++ b/layout/generic/BlockReflowInput.cpp
@@ -196,17 +196,17 @@ BlockReflowInput::ComputeReplacedBlockOf
iEndOffset = std::max(iEndOffset, 0); // in case of negative margin
}
aIStartResult = iStartOffset;
aIEndResult = iEndOffset;
}
static nscoord
GetBEndMarginClone(nsIFrame* aFrame,
- nsRenderingContext* aRenderingContext,
+ gfxContext* aRenderingContext,
const LogicalRect& aContentArea,
WritingMode aWritingMode)
{
if (aFrame->StyleBorder()->mBoxDecorationBreak ==
StyleBoxDecorationBreak::Clone) {
SizeComputationInput os(aFrame, aRenderingContext, aWritingMode,
aContentArea.ISize(aWritingMode));
return os.ComputedLogicalMargin().
--- a/layout/generic/ReflowInput.cpp
+++ b/layout/generic/ReflowInput.cpp
@@ -50,17 +50,17 @@ enum eNormalLineHeightControl {
};
static eNormalLineHeightControl sNormalLineHeightControl = eUninitialized;
// Initialize a <b>root</b> reflow state with a rendering context to
// use for measuring things.
ReflowInput::ReflowInput(nsPresContext* aPresContext,
nsIFrame* aFrame,
- nsRenderingContext* aRenderingContext,
+ gfxContext* aRenderingContext,
const LogicalSize& aAvailableSpace,
uint32_t aFlags)
: SizeComputationInput(aFrame, aRenderingContext)
, mBlockDelta(0)
, mOrthogonalLimit(NS_UNCONSTRAINEDSIZE)
, mReflowDepth(0)
{
NS_PRECONDITION(aRenderingContext, "no rendering context");
@@ -155,17 +155,17 @@ FontSizeInflationListMarginAdjustment(co
}
// NOTE: If we ever want to use SizeComputationInput for a flex item or a
// grid item, we need to make it take the containing-block block-size as
// well as the inline-size, since flex items and grid items resolve
// block-direction percent margins and padding against the
// containing-block block-size, rather than its inline-size.
SizeComputationInput::SizeComputationInput(nsIFrame *aFrame,
- nsRenderingContext *aRenderingContext,
+ gfxContext *aRenderingContext,
WritingMode aContainingBlockWritingMode,
nscoord aContainingBlockISize)
: mFrame(aFrame)
, mRenderingContext(aRenderingContext)
, mWritingMode(aFrame->GetWritingMode())
{
MOZ_ASSERT(!aFrame->IsFlexOrGridItem(),
"We're about to resolve percent margin & padding "
--- a/layout/generic/ReflowInput.h
+++ b/layout/generic/ReflowInput.h
@@ -9,23 +9,23 @@
#define mozilla_ReflowInput_h
#include "nsMargin.h"
#include "nsStyleCoord.h"
#include "nsIFrame.h"
#include "mozilla/Assertions.h"
#include <algorithm>
+class gfxContext;
class nsFloatManager;
struct nsHypotheticalPosition;
class nsIPercentBSizeObserver;
class nsLineLayout;
class nsPlaceholderFrame;
class nsPresContext;
-class nsRenderingContext;
/**
* @return aValue clamped to [aMinValue, aMaxValue].
*
* @note This function needs to handle aMinValue > aMaxValue. In that case,
* aMinValue is returned.
* @see http://www.w3.org/TR/CSS21/visudet.html#min-max-widths
* @see http://www.w3.org/TR/CSS21/visudet.html#min-max-heights
@@ -103,17 +103,17 @@ struct SizeComputationInput {
public:
typedef mozilla::WritingMode WritingMode;
typedef mozilla::LogicalMargin LogicalMargin;
// The frame being reflowed.
nsIFrame* mFrame;
// Rendering context to use for measurement.
- nsRenderingContext* mRenderingContext;
+ gfxContext* mRenderingContext;
const nsMargin& ComputedPhysicalMargin() const { return mComputedMargin; }
const nsMargin& ComputedPhysicalBorderPadding() const { return mComputedBorderPadding; }
const nsMargin& ComputedPhysicalPadding() const { return mComputedPadding; }
// We may need to eliminate the (few) users of these writable-reference accessors
// as part of migrating to logical coordinates.
nsMargin& ComputedPhysicalMargin() { return mComputedMargin; }
@@ -160,24 +160,24 @@ protected:
// Cached copy of the border + padding values
nsMargin mComputedBorderPadding;
// Computed padding values
nsMargin mComputedPadding;
public:
// Callers using this constructor must call InitOffsets on their own.
- SizeComputationInput(nsIFrame *aFrame, nsRenderingContext *aRenderingContext)
+ SizeComputationInput(nsIFrame *aFrame, gfxContext *aRenderingContext)
: mFrame(aFrame)
, mRenderingContext(aRenderingContext)
, mWritingMode(aFrame->GetWritingMode())
{
}
- SizeComputationInput(nsIFrame *aFrame, nsRenderingContext *aRenderingContext,
+ SizeComputationInput(nsIFrame *aFrame, gfxContext *aRenderingContext,
mozilla::WritingMode aContainingBlockWritingMode,
nscoord aContainingBlockISize);
struct ReflowInputFlags {
ReflowInputFlags() { memset(this, 0, sizeof(*this)); }
bool mSpecialBSizeReflow : 1; // used by tables to communicate special reflow (in process) to handle
// percent bsize frames inside cells which may not have computed bsizes
bool mNextInFlowUntouched : 1; // nothing in the frame's next-in-flow (or its descendants)
@@ -680,17 +680,17 @@ public:
* @param aRenderingContext The rendering context to be used for measurements.
* @param aAvailableSpace See comments for availableHeight and availableWidth
* members.
* @param aFlags A set of flags used for additional boolean parameters (see
* below).
*/
ReflowInput(nsPresContext* aPresContext,
nsIFrame* aFrame,
- nsRenderingContext* aRenderingContext,
+ gfxContext* aRenderingContext,
const mozilla::LogicalSize& aAvailableSpace,
uint32_t aFlags = 0);
/**
* Initialize a reflow state for a child frame's reflow. Some parts of the
* state are copied from the parent's reflow state. The remainder is computed.
*
* @param aPresContext Must be equal to aFrame->PresContext().
--- a/layout/generic/TextOverflow.cpp
+++ b/layout/generic/TextOverflow.cpp
@@ -3,27 +3,27 @@
/* 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 "TextOverflow.h"
#include <algorithm>
// Please maintain alphabetical order below
+#include "gfxContext.h"
#include "nsBlockFrame.h"
#include "nsCaret.h"
#include "nsContentUtils.h"
#include "nsCSSAnonBoxes.h"
#include "nsFontMetrics.h"
#include "nsGfxScrollFrame.h"
#include "nsIScrollableFrame.h"
#include "nsLayoutUtils.h"
#include "nsPresContext.h"
#include "nsRect.h"
-#include "nsRenderingContext.h"
#include "nsTextFrame.h"
#include "nsIFrameInlines.h"
#include "mozilla/ArrayUtils.h"
#include "mozilla/Likely.h"
#include "nsISelection.h"
namespace mozilla {
namespace css {
@@ -194,84 +194,84 @@ public:
return nsRect();
}
}
bool snap;
return GetBounds(aBuilder, &snap);
}
virtual void Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) override;
+ gfxContext* aCtx) override;
virtual uint32_t GetPerFrameKey() override {
return (mIndex << nsDisplayItem::TYPE_BITS) | nsDisplayItem::GetPerFrameKey();
}
- void PaintTextToContext(nsRenderingContext* aCtx,
+ void PaintTextToContext(gfxContext* aCtx,
nsPoint aOffsetFromRect);
NS_DISPLAY_DECL_NAME("TextOverflow", TYPE_TEXT_OVERFLOW)
private:
nsRect mRect; // in reference frame coordinates
const nsStyleTextOverflowSide* mStyle;
nscoord mAscent; // baseline for the marker text in mRect
uint32_t mIndex;
};
static void
-PaintTextShadowCallback(nsRenderingContext* aCtx,
+PaintTextShadowCallback(gfxContext* aCtx,
nsPoint aShadowOffset,
const nscolor& aShadowColor,
void* aData)
{
reinterpret_cast<nsDisplayTextOverflowMarker*>(aData)->
PaintTextToContext(aCtx, aShadowOffset);
}
void
nsDisplayTextOverflowMarker::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx)
+ gfxContext* aCtx)
{
nscolor foregroundColor = nsLayoutUtils::
GetColor(mFrame, &nsStyleText::mWebkitTextFillColor);
// Paint the text-shadows for the overflow marker
nsLayoutUtils::PaintTextShadow(mFrame, aCtx, mRect, mVisibleRect,
foregroundColor, PaintTextShadowCallback,
(void*)this);
- aCtx->ThebesContext()->SetColor(gfx::Color::FromABGR(foregroundColor));
+ aCtx->SetColor(gfx::Color::FromABGR(foregroundColor));
PaintTextToContext(aCtx, nsPoint(0, 0));
}
void
-nsDisplayTextOverflowMarker::PaintTextToContext(nsRenderingContext* aCtx,
+nsDisplayTextOverflowMarker::PaintTextToContext(gfxContext* aCtx,
nsPoint aOffsetFromRect)
{
WritingMode wm = mFrame->GetWritingMode();
nsPoint pt(mRect.x, mRect.y);
if (wm.IsVertical()) {
if (wm.IsVerticalLR()) {
pt.x = NSToCoordFloor(nsLayoutUtils::GetSnappedBaselineX(
- mFrame, aCtx->ThebesContext(), pt.x, mAscent));
+ mFrame, aCtx, pt.x, mAscent));
} else {
pt.x = NSToCoordFloor(nsLayoutUtils::GetSnappedBaselineX(
- mFrame, aCtx->ThebesContext(), pt.x + mRect.width, -mAscent));
+ mFrame, aCtx, pt.x + mRect.width, -mAscent));
}
} else {
pt.y = NSToCoordFloor(nsLayoutUtils::GetSnappedBaselineY(
- mFrame, aCtx->ThebesContext(), pt.y, mAscent));
+ mFrame, aCtx, pt.y, mAscent));
}
pt += aOffsetFromRect;
if (mStyle->mType == NS_STYLE_TEXT_OVERFLOW_ELLIPSIS) {
gfxTextRun* textRun = GetEllipsisTextRun(mFrame);
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()));
+ gfxTextRun::DrawParams(aCtx));
}
} else {
RefPtr<nsFontMetrics> fm =
nsLayoutUtils::GetInflatedFontMetricsForFrame(mFrame);
nsLayoutUtils::DrawString(mFrame, *fm, aCtx, mStyle->mString.get(),
mStyle->mString.Length(), pt);
}
}
@@ -847,21 +847,21 @@ TextOverflow::Marker::SetupString(nsIFra
if (mStyle->mType == NS_STYLE_TEXT_OVERFLOW_ELLIPSIS) {
gfxTextRun* textRun = GetEllipsisTextRun(aFrame);
if (textRun) {
mISize = textRun->GetAdvanceWidth();
} else {
mISize = 0;
}
} else {
- nsRenderingContext rc(
- aFrame->PresContext()->PresShell()->CreateReferenceRenderingContext());
+ RefPtr<gfxContext> rc =
+ aFrame->PresContext()->PresShell()->CreateReferenceRenderingContext();
RefPtr<nsFontMetrics> fm =
nsLayoutUtils::GetInflatedFontMetricsForFrame(aFrame);
mISize = nsLayoutUtils::AppUnitWidthOfStringBidi(mStyle->mString, aFrame,
- *fm, rc);
+ *fm, *rc);
}
mIntrinsicISize = mISize;
mInitialized = true;
}
} // namespace css
} // namespace mozilla
--- a/layout/generic/ViewportFrame.cpp
+++ b/layout/generic/ViewportFrame.cpp
@@ -206,30 +206,30 @@ ViewportFrame::RemoveFrame(ChildListID
nsIFrame* aOldFrame)
{
NS_ASSERTION(aListID == kPrincipalList, "unexpected child list");
nsContainerFrame::RemoveFrame(aListID, aOldFrame);
}
#endif
/* virtual */ nscoord
-ViewportFrame::GetMinISize(nsRenderingContext *aRenderingContext)
+ViewportFrame::GetMinISize(gfxContext *aRenderingContext)
{
nscoord result;
DISPLAY_MIN_WIDTH(this, result);
if (mFrames.IsEmpty())
result = 0;
else
result = mFrames.FirstChild()->GetMinISize(aRenderingContext);
return result;
}
/* virtual */ nscoord
-ViewportFrame::GetPrefISize(nsRenderingContext *aRenderingContext)
+ViewportFrame::GetPrefISize(gfxContext *aRenderingContext)
{
nscoord result;
DISPLAY_PREF_WIDTH(this, result);
if (mFrames.IsEmpty())
result = 0;
else
result = mFrames.FirstChild()->GetPrefISize(aRenderingContext);
--- a/layout/generic/ViewportFrame.h
+++ b/layout/generic/ViewportFrame.h
@@ -50,18 +50,18 @@ public:
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) override;
void BuildDisplayListForTopLayer(nsDisplayListBuilder* aBuilder,
nsDisplayList* aList);
- virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override;
- virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override;
+ virtual nscoord GetMinISize(gfxContext *aRenderingContext) override;
+ virtual nscoord GetPrefISize(gfxContext *aRenderingContext) override;
virtual void Reflow(nsPresContext* aPresContext,
ReflowOutput& aDesiredSize,
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus) override;
virtual bool ComputeCustomOverflow(nsOverflowAreas& aOverflowAreas) override;
/**
--- a/layout/generic/nsBackdropFrame.cpp
+++ b/layout/generic/nsBackdropFrame.cpp
@@ -45,17 +45,17 @@ nsBackdropFrame::BuildDisplayList(nsDisp
display == mozilla::StyleDisplay::Contents) {
return;
}
DisplayBorderBackgroundOutline(aBuilder, aLists);
}
/* virtual */ LogicalSize
-nsBackdropFrame::ComputeAutoSize(nsRenderingContext* aRenderingContext,
+nsBackdropFrame::ComputeAutoSize(gfxContext* aRenderingContext,
WritingMode aWM,
const LogicalSize& aCBSize,
nscoord aAvailableISize,
const LogicalSize& aMargin,
const LogicalSize& aBorder,
const LogicalSize& aPadding,
ComputeSizeFlags aFlags)
{
--- a/layout/generic/nsBackdropFrame.h
+++ b/layout/generic/nsBackdropFrame.h
@@ -24,17 +24,17 @@ public:
virtual nsresult GetFrameName(nsAString& aResult) const override;
#endif
virtual nsStyleContext*
GetParentStyleContext(nsIFrame** aProviderFrame) const override;
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) override;
virtual mozilla::LogicalSize
- ComputeAutoSize(nsRenderingContext* aRenderingContext,
+ ComputeAutoSize(gfxContext* aRenderingContext,
mozilla::WritingMode aWM,
const mozilla::LogicalSize& aCBSize,
nscoord aAvailableISize,
const mozilla::LogicalSize& aMargin,
const mozilla::LogicalSize& aBorder,
const mozilla::LogicalSize& aPadding,
ComputeSizeFlags aFlags) override;
virtual void Reflow(nsPresContext* aPresContext,
--- a/layout/generic/nsBlockFrame.cpp
+++ b/layout/generic/nsBlockFrame.cpp
@@ -6,16 +6,18 @@
/*
* rendering object for CSS display:block, inline-block, and list-item
* boxes, also used for various anonymous boxes
*/
#include "nsBlockFrame.h"
+#include "gfxContext.h"
+
#include "mozilla/DebugOnly.h"
#include "mozilla/Maybe.h"
#include "mozilla/UniquePtr.h"
#include "nsCOMPtr.h"
#include "nsAbsoluteContainingBlock.h"
#include "nsBlockReflowContext.h"
#include "BlockReflowInput.h"
@@ -42,17 +44,16 @@
#include <algorithm>
#ifdef ACCESSIBILITY
#include "nsIDOMHTMLDocument.h"
#endif
#include "nsLayoutUtils.h"
#include "nsDisplayList.h"
#include "nsCSSAnonBoxes.h"
#include "nsCSSFrameConstructor.h"
-#include "nsRenderingContext.h"
#include "TextOverflow.h"
#include "nsIFrameInlines.h"
#include "CounterStyleManager.h"
#include "nsISelection.h"
#include "mozilla/dom/HTMLDetailsElement.h"
#include "mozilla/dom/HTMLSummaryElement.h"
#include "mozilla/StyleSetHandle.h"
#include "mozilla/StyleSetHandleInlines.h"
@@ -690,17 +691,17 @@ nsBlockFrame::CheckIntrinsicCacheAgainst
AddStateBits(NS_BLOCK_FRAME_INTRINSICS_INFLATED);
} else {
RemoveStateBits(NS_BLOCK_FRAME_INTRINSICS_INFLATED);
}
}
}
/* virtual */ nscoord
-nsBlockFrame::GetMinISize(nsRenderingContext *aRenderingContext)
+nsBlockFrame::GetMinISize(gfxContext *aRenderingContext)
{
nsIFrame* firstInFlow = FirstContinuation();
if (firstInFlow != this)
return firstInFlow->GetMinISize(aRenderingContext);
DISPLAY_MIN_WIDTH(this, mMinWidth);
CheckIntrinsicCacheAgainstShrinkWrapState();
@@ -778,17 +779,17 @@ nsBlockFrame::GetMinISize(nsRenderingCon
}
data.ForceBreak();
mMinWidth = data.mPrevLines;
return mMinWidth;
}
/* virtual */ nscoord
-nsBlockFrame::GetPrefISize(nsRenderingContext *aRenderingContext)
+nsBlockFrame::GetPrefISize(gfxContext *aRenderingContext)
{
nsIFrame* firstInFlow = FirstContinuation();
if (firstInFlow != this)
return firstInFlow->GetPrefISize(aRenderingContext);
DISPLAY_PREF_WIDTH(this, mPrefWidth);
CheckIntrinsicCacheAgainstShrinkWrapState();
@@ -888,17 +889,17 @@ nsBlockFrame::ComputeTightBounds(DrawTar
// be conservative
if (StyleContext()->HasTextDecorationLines()) {
return GetVisualOverflowRect();
}
return ComputeSimpleTightBounds(aDrawTarget);
}
/* virtual */ nsresult
-nsBlockFrame::GetPrefWidthTightBounds(nsRenderingContext* aRenderingContext,
+nsBlockFrame::GetPrefWidthTightBounds(gfxContext* aRenderingContext,
nscoord* aX,
nscoord* aXMost)
{
nsIFrame* firstInFlow = FirstContinuation();
if (firstInFlow != this) {
return firstInFlow->GetPrefWidthTightBounds(aRenderingContext, aX, aXMost);
}
--- a/layout/generic/nsBlockFrame.h
+++ b/layout/generic/nsBlockFrame.h
@@ -269,22 +269,22 @@ public:
nsBulletFrame* outside = GetOutsideBullet();
return outside ? outside : GetInsideBullet();
}
void MarkIntrinsicISizesDirty() override;
private:
void CheckIntrinsicCacheAgainstShrinkWrapState();
public:
- nscoord GetMinISize(nsRenderingContext *aRenderingContext) override;
- nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override;
+ nscoord GetMinISize(gfxContext *aRenderingContext) override;
+ nscoord GetPrefISize(gfxContext *aRenderingContext) override;
nsRect ComputeTightBounds(DrawTarget* aDrawTarget) const override;
- nsresult GetPrefWidthTightBounds(nsRenderingContext* aContext,
+ nsresult GetPrefWidthTightBounds(gfxContext* aContext,
nscoord* aX,
nscoord* aXMost) override;
/**
* Compute the final block size of this frame.
*
* @param aReflowInput Data structure passed from parent during reflow.
* @param aReflowStatus A pointer to the reflow status for when we're finished
--- a/layout/generic/nsBulletFrame.cpp
+++ b/layout/generic/nsBulletFrame.cpp
@@ -3,16 +3,17 @@
* 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/. */
/* rendering object for list-item bullets */
#include "nsBulletFrame.h"
#include "gfx2DGlue.h"
+#include "gfxContext.h"
#include "gfxPrefs.h"
#include "gfxUtils.h"
#include "mozilla/gfx/2D.h"
#include "mozilla/gfx/PathHelpers.h"
#include "mozilla/layers/LayersMessages.h"
#include "mozilla/layers/StackingContextHelper.h"
#include "mozilla/layers/WebRenderDisplayItemLayer.h"
#include "mozilla/layers/WebRenderMessages.h"
@@ -21,17 +22,16 @@
#include "nsCOMPtr.h"
#include "nsFontMetrics.h"
#include "nsGkAtoms.h"
#include "nsGenericHTMLElement.h"
#include "nsAttrValueInlines.h"
#include "nsPresContext.h"
#include "nsIPresShell.h"
#include "nsIDocument.h"
-#include "nsRenderingContext.h"
#include "nsDisplayList.h"
#include "nsCounterManager.h"
#include "nsBidiUtils.h"
#include "CounterStyleManager.h"
#include "UnitTransforms.h"
#include "imgIContainer.h"
#include "ImageLayers.h"
@@ -225,17 +225,17 @@ public:
void
CreateWebRenderCommands(nsDisplayItem* aItem,
wr::DisplayListBuilder& aBuilder,
const layers::StackingContextHelper& aSc,
nsTArray<layers::WebRenderParentCommand>& aParentCommands,
layers::WebRenderDisplayItemLayer* aLayer);
DrawResult
- Paint(nsRenderingContext& aRenderingContext, nsPoint aPt,
+ Paint(gfxContext& aRenderingContext, nsPoint aPt,
const nsRect& aDirtyRect, uint32_t aFlags,
bool aDisableSubpixelAA, nsIFrame* aFrame);
bool
IsImageType() const
{
return mListStyleType == NS_STYLE_LIST_STYLE_NONE && mImage;
}
@@ -328,23 +328,23 @@ BulletRenderer::CreateWebRenderCommands(
CreateWebRenderCommandsForPath(aItem, aBuilder, aSc, aParentCommands, aLayer);
} else {
MOZ_ASSERT(IsTextType());
CreateWebRenderCommandsForText(aItem, aBuilder, aSc, aLayer);
}
}
DrawResult
-BulletRenderer::Paint(nsRenderingContext& aRenderingContext, nsPoint aPt,
+BulletRenderer::Paint(gfxContext& aRenderingContext, nsPoint aPt,
const nsRect& aDirtyRect, uint32_t aFlags,
bool aDisableSubpixelAA, nsIFrame* aFrame)
{
if (IsImageType()) {
SamplingFilter filter = nsLayoutUtils::GetSamplingFilterForFrame(aFrame);
- return nsLayoutUtils::DrawSingleImage(*aRenderingContext.ThebesContext(),
+ return nsLayoutUtils::DrawSingleImage(aRenderingContext,
aFrame->PresContext(), mImage, filter,
mDest, aDirtyRect,
/* no SVGImageContext */ Nothing(),
aFlags);
}
if (IsPathType()) {
DrawTarget* drawTarget = aRenderingContext.GetDrawTarget();
@@ -365,18 +365,17 @@ BulletRenderer::Paint(nsRenderingContext
}
}
if (IsTextType()) {
DrawTarget* drawTarget = aRenderingContext.GetDrawTarget();
DrawTargetAutoDisableSubpixelAntialiasing
disable(drawTarget, aDisableSubpixelAA);
- aRenderingContext.ThebesContext()->SetColor(
- Color::FromABGR(mColor));
+ aRenderingContext.SetColor(Color::FromABGR(mColor));
nsPresContext* presContext = aFrame->PresContext();
if (!presContext->BidiEnabled() && HasRTLChars(mText)) {
presContext->SetBidiEnabled();
}
nsLayoutUtils::DrawString(aFrame, *mFontMetrics, &aRenderingContext,
mText.get(), mText.Length(), mPoint);
}
@@ -387,31 +386,30 @@ BulletRenderer::Paint(nsRenderingContext
bool
BulletRenderer::BuildGlyphForText(nsDisplayItem* aItem, bool disableSubpixelAA)
{
MOZ_ASSERT(IsTextType());
RefPtr<DrawTargetCapture> capture =
gfxPlatform::GetPlatform()->ScreenReferenceDrawTarget()->CreateCaptureDT(IntSize());
RefPtr<gfxContext> captureCtx = gfxContext::CreateOrNull(capture);
- nsRenderingContext ctx(captureCtx);
{
DrawTargetAutoDisableSubpixelAntialiasing
disable(capture, disableSubpixelAA);
- ctx.ThebesContext()->SetColor(
+ captureCtx->SetColor(
Color::FromABGR(mColor));
nsPresContext* presContext = aItem->Frame()->PresContext();
if (!presContext->BidiEnabled() && HasRTLChars(mText)) {
presContext->SetBidiEnabled();
}
- nsLayoutUtils::DrawString(aItem->Frame(), *mFontMetrics, &ctx,
+ nsLayoutUtils::DrawString(aItem->Frame(), *mFontMetrics, captureCtx,
mText.get(), mText.Length(), mPoint);
}
layers::GlyphArray* g = mGlyphs.AppendElement();
std::vector<Glyph> glyphs;
Color color;
if (!capture->ContainsOnlyColoredGlyphs(mFont, color, glyphs)) {
mFont = nullptr;
@@ -548,17 +546,17 @@ public:
layers::WebRenderDisplayItemLayer* aLayer) override;
virtual void HitTest(nsDisplayListBuilder* aBuilder, const nsRect& aRect,
HitTestState* aState,
nsTArray<nsIFrame*> *aOutFrames) override {
aOutFrames->AppendElement(mFrame);
}
virtual void Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) override;
+ gfxContext* aCtx) override;
NS_DISPLAY_DECL_NAME("Bullet", TYPE_BULLET)
virtual nsRect GetComponentAlphaBounds(nsDisplayListBuilder* aBuilder) override
{
bool snap;
return GetBounds(aBuilder, &snap);
}
@@ -605,20 +603,19 @@ nsDisplayBullet::GetLayerState(nsDisplay
const ContainerLayerParameters& aParameters)
{
if (!ShouldUseAdvancedLayer(aManager, gfxPrefs::LayersAllowBulletLayers)) {
return LAYER_NONE;
}
RefPtr<gfxContext> screenRefCtx =
gfxContext::CreateOrNull(gfxPlatform::GetPlatform()->ScreenReferenceDrawTarget());
- nsRenderingContext ctx(screenRefCtx);
Maybe<BulletRenderer> br = static_cast<nsBulletFrame*>(mFrame)->
- CreateBulletRenderer(ctx, ToReferenceFrame());
+ CreateBulletRenderer(*screenRefCtx, ToReferenceFrame());
if (!br) {
return LAYER_NONE;
}
if (br->IsImageType()) {
uint32_t flags = aBuilder->ShouldSyncDecodeImages()
? imgIContainer::FLAG_SYNC_DECODE
@@ -659,17 +656,17 @@ nsDisplayBullet::CreateWebRenderCommands
{
if (!mBulletRenderer)
return;
mBulletRenderer->CreateWebRenderCommands(this, aBuilder, aSc, aParentCommands, aLayer);
}
void nsDisplayBullet::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx)
+ gfxContext* aCtx)
{
uint32_t flags = imgIContainer::FLAG_NONE;
if (aBuilder->ShouldSyncDecodeImages()) {
flags |= imgIContainer::FLAG_SYNC_DECODE;
}
DrawResult result = static_cast<nsBulletFrame*>(mFrame)->
PaintBullet(*aCtx, ToReferenceFrame(), mVisibleRect, flags,
@@ -688,17 +685,17 @@ nsBulletFrame::BuildDisplayList(nsDispla
DO_GLOBAL_REFLOW_COUNT_DSP("nsBulletFrame");
aLists.Content()->AppendNewToTop(
new (aBuilder) nsDisplayBullet(aBuilder, this));
}
Maybe<BulletRenderer>
-nsBulletFrame::CreateBulletRenderer(nsRenderingContext& aRenderingContext, nsPoint aPt)
+nsBulletFrame::CreateBulletRenderer(gfxContext& aRenderingContext, nsPoint aPt)
{
const nsStyleList* myList = StyleList();
CounterStyle* listStyleType = myList->mCounterStyle;
nsMargin padding = mPadding.GetPhysicalMargin(GetWritingMode());
if (myList->GetListStyleImage() && mImageRequest) {
uint32_t status;
mImageRequest->GetImageStatus(&status);
@@ -824,42 +821,41 @@ nsBulletFrame::CreateBulletRenderer(nsRe
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()) {
if (wm.IsVerticalLR()) {
aPt.x = NSToCoordRound(nsLayoutUtils::GetSnappedBaselineX(
- this, ctx, aPt.x, ascent));
+ this, &aRenderingContext, aPt.x, ascent));
} else {
aPt.x = NSToCoordRound(nsLayoutUtils::GetSnappedBaselineX(
- this, ctx, aPt.x + mRect.width,
+ this, &aRenderingContext, aPt.x + mRect.width,
-ascent));
}
} else {
aPt.y = NSToCoordRound(nsLayoutUtils::GetSnappedBaselineY(
- this, ctx, aPt.y, ascent));
+ this, &aRenderingContext, aPt.y, ascent));
}
BulletRenderer br(text, fm, color, aPt, listStyleType->GetStyle());
return Some(br);
}
}
MOZ_CRASH("unreachable");
return Nothing();
}
DrawResult
-nsBulletFrame::PaintBullet(nsRenderingContext& aRenderingContext, nsPoint aPt,
+nsBulletFrame::PaintBullet(gfxContext& aRenderingContext, nsPoint aPt,
const nsRect& aDirtyRect, uint32_t aFlags,
bool aDisableSubpixelAA)
{
Maybe<BulletRenderer> br = CreateBulletRenderer(aRenderingContext, aPt);
if (!br) {
return DrawResult::SUCCESS;
}
@@ -939,17 +935,17 @@ void
nsBulletFrame::AppendSpacingToPadding(nsFontMetrics* aFontMetrics,
LogicalMargin* aPadding)
{
aPadding->IEnd(GetWritingMode()) += aFontMetrics->EmHeight() / 2;
}
void
nsBulletFrame::GetDesiredSize(nsPresContext* aCX,
- nsRenderingContext *aRenderingContext,
+ gfxContext *aRenderingContext,
ReflowOutput& aMetrics,
float aFontSizeInflation,
LogicalMargin* aPadding)
{
// 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);
@@ -1075,29 +1071,29 @@ nsBulletFrame::Reflow(nsPresContext* aPr
// 397294).
aMetrics.SetOverflowAreasToDesiredBounds();
aStatus.Reset();
NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aMetrics);
}
/* virtual */ nscoord
-nsBulletFrame::GetMinISize(nsRenderingContext *aRenderingContext)
+nsBulletFrame::GetMinISize(gfxContext *aRenderingContext)
{
WritingMode wm = GetWritingMode();
ReflowOutput reflowOutput(wm);
DISPLAY_MIN_WIDTH(this, reflowOutput.ISize(wm));
LogicalMargin padding(wm);
GetDesiredSize(PresContext(), aRenderingContext, reflowOutput, 1.0f, &padding);
reflowOutput.ISize(wm) += padding.IStartEnd(wm);
return reflowOutput.ISize(wm);
}
/* virtual */ nscoord
-nsBulletFrame::GetPrefISize(nsRenderingContext *aRenderingContext)
+nsBulletFrame::GetPrefISize(gfxContext *aRenderingContext)
{
WritingMode wm = GetWritingMode();
ReflowOutput metrics(wm);
DISPLAY_PREF_WIDTH(this, metrics.ISize(wm));
LogicalMargin padding(wm);
GetDesiredSize(PresContext(), aRenderingContext, metrics, 1.0f, &padding);
metrics.ISize(wm) += padding.IStartEnd(wm);
return metrics.ISize(wm);
@@ -1113,28 +1109,28 @@ IsIgnoreable(const nsIFrame* aFrame, nsc
return false;
}
auto listStyle = aFrame->StyleList();
return listStyle->mCounterStyle->IsNone() &&
!listStyle->GetListStyleImage();
}
/* virtual */ void
-nsBulletFrame::AddInlineMinISize(nsRenderingContext* aRenderingContext,
+nsBulletFrame::AddInlineMinISize(gfxContext* aRenderingContext,
nsIFrame::InlineMinISizeData* aData)
{
nscoord isize = nsLayoutUtils::IntrinsicForContainer(aRenderingContext,
this, nsLayoutUtils::MIN_ISIZE);
if (MOZ_LIKELY(!::IsIgnoreable(this, isize))) {
aData->DefaultAddInlineMinISize(this, isize);
}
}
/* virtual */ void
-nsBulletFrame::AddInlinePrefISize(nsRenderingContext* aRenderingContext,
+nsBulletFrame::AddInlinePrefISize(gfxContext* aRenderingContext,
nsIFrame::InlinePrefISizeData* aData)
{
nscoord isize = nsLayoutUtils::IntrinsicForContainer(aRenderingContext,
this, nsLayoutUtils::PREF_ISIZE);
if (MOZ_LIKELY(!::IsIgnoreable(this, isize))) {
aData->DefaultAddInlinePrefISize(isize);
}
}
--- a/layout/generic/nsBulletFrame.h
+++ b/layout/generic/nsBulletFrame.h
@@ -76,35 +76,35 @@ public:
#ifdef DEBUG_FRAME_DUMP
virtual nsresult GetFrameName(nsAString& aResult) const override;
#endif
virtual void Reflow(nsPresContext* aPresContext,
ReflowOutput& aMetrics,
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus) override;
- virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override;
- virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override;
- void AddInlineMinISize(nsRenderingContext* aRenderingContext,
+ virtual nscoord GetMinISize(gfxContext *aRenderingContext) override;
+ virtual nscoord GetPrefISize(gfxContext *aRenderingContext) override;
+ void AddInlineMinISize(gfxContext* aRenderingContext,
nsIFrame::InlineMinISizeData* aData) override;
- void AddInlinePrefISize(nsRenderingContext* aRenderingContext,
+ void AddInlinePrefISize(gfxContext* aRenderingContext,
nsIFrame::InlinePrefISizeData* aData) override;
// nsBulletFrame
int32_t SetListItemOrdinal(int32_t aNextOrdinal, bool* aChanged,
int32_t aIncrement);
/* get list item text, with prefix & suffix */
void GetListItemText(nsAString& aResult);
void GetSpokenText(nsAString& aText);
Maybe<BulletRenderer>
- CreateBulletRenderer(nsRenderingContext& aRenderingContext, nsPoint aPt);
- DrawResult PaintBullet(nsRenderingContext& aRenderingContext, nsPoint aPt,
+ CreateBulletRenderer(gfxContext& aRenderingContext, nsPoint aPt);
+ DrawResult PaintBullet(gfxContext& aRenderingContext, nsPoint aPt,
const nsRect& aDirtyRect, uint32_t aFlags,
bool aDisableSubpixelAA);
virtual bool IsEmpty() override;
virtual bool IsSelfEmpty() override;
virtual nscoord GetLogicalBaseline(mozilla::WritingMode aWritingMode) const override;
float GetFontSizeInflation() const;
@@ -118,17 +118,17 @@ public:
already_AddRefed<imgIContainer> GetImage() const;
protected:
nsresult OnSizeAvailable(imgIRequest* aRequest, imgIContainer* aImage);
void AppendSpacingToPadding(nsFontMetrics* aFontMetrics,
mozilla::LogicalMargin* aPadding);
void GetDesiredSize(nsPresContext* aPresContext,
- nsRenderingContext *aRenderingContext,
+ gfxContext *aRenderingContext,
ReflowOutput& aMetrics,
float aFontSizeInflation,
mozilla::LogicalMargin* aPadding);
void GetLoadGroup(nsPresContext *aPresContext, nsILoadGroup **aLoadGroup);
nsIDocument* GetOurCurrentDoc() const;
mozilla::LogicalMargin mPadding;
--- a/layout/generic/nsCanvasFrame.cpp
+++ b/layout/generic/nsCanvasFrame.cpp
@@ -3,22 +3,22 @@
* 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/. */
/* rendering object that goes directly inside the document's scrollbars */
#include "nsCanvasFrame.h"
#include "AccessibleCaretEventHub.h"
+#include "gfxContext.h"
#include "gfxUtils.h"
#include "nsContainerFrame.h"
#include "nsCSSRendering.h"
#include "nsPresContext.h"
#include "nsStyleContext.h"
-#include "nsRenderingContext.h"
#include "nsGkAtoms.h"
#include "nsIFrameInlines.h"
#include "nsIPresShell.h"
#include "nsDisplayList.h"
#include "nsCSSFrameConstructor.h"
#include "nsFrameManager.h"
#include "gfxPlatform.h"
#include "nsPrintfCString.h"
@@ -248,17 +248,17 @@ nsRect nsCanvasFrame::CanvasArea() const
nsRect portRect = scrollableFrame->GetScrollPortRect();
result.UnionRect(result, nsRect(nsPoint(0, 0), portRect.Size()));
}
return result;
}
void
nsDisplayCanvasBackgroundColor::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx)
+ gfxContext* aCtx)
{
nsCanvasFrame* frame = static_cast<nsCanvasFrame*>(mFrame);
nsPoint offset = ToReferenceFrame();
nsRect bgClipRect = frame->CanvasArea() + offset;
if (NS_GET_A(mColor) > 0) {
DrawTarget* drawTarget = aCtx->GetDrawTarget();
int32_t appUnitsPerDevPixel = mFrame->PresContext()->AppUnitsPerDevPixel();
Rect devPxRect =
@@ -342,24 +342,24 @@ static void BlitSurface(DrawTarget* aDes
aDest->DrawSurface(source,
Rect(aRect.x, aRect.y, aRect.width, aRect.height),
Rect(0, 0, aRect.width, aRect.height));
}
#endif
void
nsDisplayCanvasBackgroundImage::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx)
+ gfxContext* aCtx)
{
nsCanvasFrame* frame = static_cast<nsCanvasFrame*>(mFrame);
nsPoint offset = ToReferenceFrame();
nsRect bgClipRect = frame->CanvasArea() + offset;
#ifndef MOZ_GFX_OPTIMIZE_MOBILE
- RefPtr<gfxContext> dest = aCtx->ThebesContext();
+ RefPtr<gfxContext> dest = aCtx;
gfxRect destRect;
if (IsSingleFixedPositionImage(aBuilder, bgClipRect, &destRect) &&
aBuilder->IsPaintingToWindow() && !aBuilder->IsCompositingCheap() &&
!dest->CurrentMatrix().HasNonIntegerTranslation()) {
// Snap image rectangle to nearest pixel boundaries. This is the right way
// to snap for this context, because we checked HasNonIntegerTranslation
// above.
destRect.Round();
@@ -373,18 +373,17 @@ nsDisplayCanvasBackgroundImage::Paint(ns
dt = destDT->CreateSimilarDrawTarget(IntSize::Ceil(destRect.width,
destRect.height),
SurfaceFormat::B8G8R8A8);
if (dt && dt->IsValid()) {
RefPtr<gfxContext> ctx = gfxContext::CreateOrNull(dt);
MOZ_ASSERT(ctx); // already checked draw target above
ctx->SetMatrix(ctx->CurrentMatrix().Translate(-destRect.x, -destRect.y));
- nsRenderingContext context(ctx);
- PaintInternal(aBuilder, &context, bgClipRect, &bgClipRect);
+ PaintInternal(aBuilder, ctx, bgClipRect, &bgClipRect);
BlitSurface(dest->GetDrawTarget(), destRect, dt);
frame->SetProperty(nsIFrame::CachedBackgroundImageDT(),
dt.forget().take());
return;
}
}
#endif
PaintInternal(aBuilder, aCtx, mVisibleRect, &bgClipRect);
@@ -423,17 +422,17 @@ nsDisplayCanvasBackgroundImage::IsSingle
*aDestRect = nsLayoutUtils::RectToGfxRect(state.mFillArea, appUnitsPerDevPixel);
return true;
}
void
nsDisplayCanvasThemedBackground::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx)
+ gfxContext* aCtx)
{
nsCanvasFrame* frame = static_cast<nsCanvasFrame*>(mFrame);
nsPoint offset = ToReferenceFrame();
nsRect bgClipRect = frame->CanvasArea() + offset;
PaintInternal(aBuilder, aCtx, mVisibleRect, &bgClipRect);
}
@@ -458,17 +457,17 @@ public:
{
*aSnap = false;
// This is an overestimate, but that's not a problem.
nsCanvasFrame* frame = static_cast<nsCanvasFrame*>(mFrame);
return frame->CanvasArea() + ToReferenceFrame();
}
virtual void Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) override
+ gfxContext* aCtx) override
{
nsCanvasFrame* frame = static_cast<nsCanvasFrame*>(mFrame);
frame->PaintFocus(aCtx->GetDrawTarget(), ToReferenceFrame());
}
NS_DISPLAY_DECL_NAME("CanvasFocus", TYPE_CANVAS_FOCUS)
};
@@ -640,29 +639,29 @@ nsCanvasFrame::PaintFocus(DrawTarget* aD
return;
}
nsCSSRendering::PaintFocus(PresContext(), aDrawTarget,
focusRect, color->mColor);
}
/* virtual */ nscoord
-nsCanvasFrame::GetMinISize(nsRenderingContext *aRenderingContext)
+nsCanvasFrame::GetMinISize(gfxContext *aRenderingContext)
{
nscoord result;
DISPLAY_MIN_WIDTH(this, result);
if (mFrames.IsEmpty())
result = 0;
else
result = mFrames.FirstChild()->GetMinISize(aRenderingContext);
return result;
}
/* virtual */ nscoord
-nsCanvasFrame::GetPrefISize(nsRenderingContext *aRenderingContext)
+nsCanvasFrame::GetPrefISize(gfxContext *aRenderingContext)
{
nscoord result;
DISPLAY_PREF_WIDTH(this, result);
if (mFrames.IsEmpty())
result = 0;
else
result = mFrames.FirstChild()->GetPrefISize(aRenderingContext);
return result;
--- a/layout/generic/nsCanvasFrame.h
+++ b/layout/generic/nsCanvasFrame.h
@@ -12,17 +12,17 @@
#include "mozilla/EventForwards.h"
#include "nsContainerFrame.h"
#include "nsIScrollPositionListener.h"
#include "nsDisplayList.h"
#include "nsIAnonymousContentCreator.h"
#include "gfxPrefs.h"
class nsPresContext;
-class nsRenderingContext;
+class gfxContext;
/**
* Root frame class.
*
* The root frame is the parent frame for the document element's frame.
* It only supports having a single child frame which must be an area
* frame.
* @note nsCanvasFrame keeps overflow container continuations of its child
@@ -52,18 +52,18 @@ public:
virtual void InsertFrames(ChildListID aListID,
nsIFrame* aPrevFrame,
nsFrameList& aFrameList) override;
#ifdef DEBUG
virtual void RemoveFrame(ChildListID aListID,
nsIFrame* aOldFrame) override;
#endif
- virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override;
- virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override;
+ virtual nscoord GetMinISize(gfxContext *aRenderingContext) override;
+ virtual nscoord GetPrefISize(gfxContext *aRenderingContext) override;
virtual void Reflow(nsPresContext* aPresContext,
ReflowOutput& aDesiredSize,
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus) override;
virtual bool IsFrameOfType(uint32_t aFlags) const override
{
return nsContainerFrame::IsFrameOfType(aFlags &
~(nsIFrame::eCanContainOverflowContainers));
@@ -169,17 +169,17 @@ public:
{
if (ShouldUseAdvancedLayer(aManager, gfxPrefs::LayersAllowCanvasBackgroundColorLayers) ||
ForceActiveLayers()) {
return mozilla::LAYER_ACTIVE;
}
return mozilla::LAYER_NONE;
}
virtual void Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) override;
+ gfxContext* aCtx) override;
void SetExtraBackgroundColor(nscolor aColor)
{
mColor = aColor;
}
NS_DISPLAY_DECL_NAME("CanvasBackgroundColor", TYPE_CANVAS_BACKGROUND_COLOR)
#ifdef MOZ_DUMP_PAINTING
@@ -189,17 +189,17 @@ public:
class nsDisplayCanvasBackgroundImage : public nsDisplayBackgroundImage {
public:
explicit nsDisplayCanvasBackgroundImage(const InitData& aInitData)
: nsDisplayBackgroundImage(aInitData)
{
}
- virtual void Paint(nsDisplayListBuilder* aBuilder, nsRenderingContext* aCtx) override;
+ virtual void Paint(nsDisplayListBuilder* aBuilder, gfxContext* aCtx) override;
virtual void NotifyRenderingChanged() override
{
mFrame->DeleteProperty(nsIFrame::CachedBackgroundImageDT());
}
// We still need to paint a background color as well as an image for this item,
// so we can't support this yet.
@@ -215,14 +215,14 @@ public:
class nsDisplayCanvasThemedBackground : public nsDisplayThemedBackground {
public:
nsDisplayCanvasThemedBackground(nsDisplayListBuilder* aBuilder, nsIFrame* aFrame)
: nsDisplayThemedBackground(aBuilder, aFrame,
aFrame->GetRectRelativeToSelf() + aBuilder->ToReferenceFrame(aFrame))
{}
- virtual void Paint(nsDisplayListBuilder* aBuilder, nsRenderingContext* aCtx) override;
+ virtual void Paint(nsDisplayListBuilder* aBuilder, gfxContext* aCtx) override;
NS_DISPLAY_DECL_NAME("CanvasThemedBackground", TYPE_CANVAS_THEMED_BACKGROUND)
};
#endif /* nsCanvasFrame_h___ */
--- a/layout/generic/nsColumnSetFrame.cpp
+++ b/layout/generic/nsColumnSetFrame.cpp
@@ -43,27 +43,27 @@ public:
virtual already_AddRefed<Layer> BuildLayer(nsDisplayListBuilder* aBuilder,
LayerManager* aManager,
const ContainerLayerParameters& aContainerParameters) override;
virtual void CreateWebRenderCommands(mozilla::wr::DisplayListBuilder& aBuilder,
const StackingContextHelper& aSc,
nsTArray<WebRenderParentCommand>& aParentCommands,
mozilla::layers::WebRenderDisplayItemLayer* aLayer) override;
virtual void Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) override;
+ gfxContext* aCtx) override;
NS_DISPLAY_DECL_NAME("ColumnRule", nsDisplayItem::TYPE_COLUMN_RULE);
private:
nsTArray<nsCSSBorderRenderer> mBorderRenderers;
};
void
nsDisplayColumnRule::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx)
+ gfxContext* aCtx)
{
static_cast<nsColumnSetFrame*>(mFrame)->
CreateBorderRenderers(mBorderRenderers, aCtx, mVisibleRect, ToReferenceFrame());
for (auto iter = mBorderRenderers.begin(); iter != mBorderRenderers.end(); iter++) {
iter->DrawBorders();
}
}
@@ -73,20 +73,19 @@ nsDisplayColumnRule::GetLayerState(nsDis
const ContainerLayerParameters& aParameters)
{
if (!gfxPrefs::LayersAllowColumnRuleLayers()) {
return LAYER_NONE;
}
RefPtr<gfxContext> screenRefCtx =
gfxContext::CreateOrNull(gfxPlatform::GetPlatform()->ScreenReferenceDrawTarget());
- nsRenderingContext ctx(screenRefCtx);
static_cast<nsColumnSetFrame*>(mFrame)->
- CreateBorderRenderers(mBorderRenderers, &ctx, mVisibleRect, ToReferenceFrame());
+ CreateBorderRenderers(mBorderRenderers, screenRefCtx, mVisibleRect, ToReferenceFrame());
if (mBorderRenderers.IsEmpty()) {
return LAYER_NONE;
}
for (auto iter = mBorderRenderers.begin(); iter != mBorderRenderers.end(); iter++) {
if (!iter->CanCreateWebRenderCommands()) {
return LAYER_NONE;
@@ -206,17 +205,17 @@ nsColumnSetFrame::CalculateBounds(const
{
combined = combined.Union(aLineRect);
}, aOffset);
return combined;
}
void
nsColumnSetFrame::CreateBorderRenderers(nsTArray<nsCSSBorderRenderer>& aBorderRenderers,
- nsRenderingContext* aCtx,
+ gfxContext* aCtx,
const nsRect& aDirtyRect,
const nsPoint& aPt)
{
WritingMode wm = GetWritingMode();
bool isVertical = wm.IsVertical();
const nsStyleColumn* colStyle = StyleColumn();
uint8_t ruleStyle;
@@ -499,17 +498,17 @@ static void MoveChildTo(nsIFrame* aChild
return;
}
aChild->SetPosition(aWM, aOrigin, aContainerSize);
nsContainerFrame::PlaceFrameView(aChild);
}
nscoord
-nsColumnSetFrame::GetMinISize(nsRenderingContext *aRenderingContext)
+nsColumnSetFrame::GetMinISize(gfxContext *aRenderingContext)
{
nscoord iSize = 0;
DISPLAY_MIN_WIDTH(this, iSize);
if (mFrames.FirstChild()) {
iSize = mFrames.FirstChild()->GetMinISize(aRenderingContext);
}
const nsStyleColumn* colStyle = StyleColumn();
nscoord colISize;
@@ -534,17 +533,17 @@ nsColumnSetFrame::GetMinISize(nsRenderin
iSize = std::max(iSize, colISize);
}
// XXX count forced column breaks here? Maybe we should return the child's
// min-width times the minimum number of columns.
return iSize;
}
nscoord
-nsColumnSetFrame::GetPrefISize(nsRenderingContext *aRenderingContext)
+nsColumnSetFrame::GetPrefISize(gfxContext *aRenderingContext)
{
// Our preferred width is our desired column width, if specified, otherwise
// the child's preferred width, times the number of columns, plus the width
// of any required column gaps
// XXX what about forced column breaks here?
nscoord result = 0;
DISPLAY_PREF_WIDTH(this, result);
const nsStyleColumn* colStyle = StyleColumn();
--- a/layout/generic/nsColumnSetFrame.h
+++ b/layout/generic/nsColumnSetFrame.h
@@ -36,18 +36,18 @@ public:
nsFrameList& aFrameList) override;
virtual void InsertFrames(ChildListID aListID,
nsIFrame* aPrevFrame,
nsFrameList& aFrameList) override;
virtual void RemoveFrame(ChildListID aListID,
nsIFrame* aOldFrame) override;
#endif
- virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override;
- virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override;
+ virtual nscoord GetMinISize(gfxContext *aRenderingContext) override;
+ virtual nscoord GetPrefISize(gfxContext *aRenderingContext) override;
/**
* Retrieve the available height for content of this frame. The available content
* height is the available height for the frame, minus borders and padding.
*/
virtual nscoord GetAvailableContentBSize(const ReflowInput& aReflowInput);
virtual nsContainerFrame* GetContentInsertionFrame() override {
@@ -87,17 +87,17 @@ public:
#ifdef DEBUG_FRAME_DUMP
virtual nsresult GetFrameName(nsAString& aResult) const override {
return MakeFrameName(NS_LITERAL_STRING("ColumnSet"), aResult);
}
#endif
nsRect CalculateBounds(const nsPoint& aOffset);
void CreateBorderRenderers(nsTArray<nsCSSBorderRenderer>& aBorderRenderers,
- nsRenderingContext* aCtx,
+ gfxContext* aCtx,
const nsRect& aDirtyRect,
const nsPoint& aPt);
protected:
nscoord mLastBalanceBSize;
nsReflowStatus mLastFrameStatus;
/**
--- a/layout/generic/nsContainerFrame.cpp
+++ b/layout/generic/nsContainerFrame.cpp
@@ -583,17 +583,17 @@ IsTopLevelWidget(nsIWidget* aWidget)
windowType == eWindowType_popup ||
windowType == eWindowType_sheet;
}
void
nsContainerFrame::SyncWindowProperties(nsPresContext* aPresContext,
nsIFrame* aFrame,
nsView* aView,
- nsRenderingContext* aRC,
+ gfxContext* aRC,
uint32_t aFlags)
{
#ifdef MOZ_XUL
if (!aView || !nsCSSRendering::IsCanvasFrame(aFrame) || !aView->HasWidget())
return;
nsCOMPtr<nsIWidget> windowWidget = GetPresContextContainerWidget(aPresContext);
if (!windowWidget || !IsTopLevelWidget(windowWidget))
@@ -722,17 +722,17 @@ static nscoord GetCoord(const nsStyleCoo
{
if (aCoord.ConvertsToLength()) {
return nsRuleNode::ComputeCoordPercentCalc(aCoord, 0);
}
return aIfNotCoord;
}
void
-nsContainerFrame::DoInlineIntrinsicISize(nsRenderingContext *aRenderingContext,
+nsContainerFrame::DoInlineIntrinsicISize(gfxContext *aRenderingContext,
InlineIntrinsicISizeData *aData,
nsLayoutUtils::IntrinsicISizeType aType)
{
if (GetPrevInFlow())
return; // Already added.
NS_PRECONDITION(aType == nsLayoutUtils::MIN_ISIZE ||
aType == nsLayoutUtils::PREF_ISIZE, "bad type");
@@ -819,17 +819,17 @@ nsContainerFrame::DoInlineIntrinsicISize
// the endSide border.
if (MOZ_LIKELY(!lastInFlow->GetNextContinuation() && sliceBreak)) {
aData->mCurrentLine += endPBM;
}
}
/* virtual */
LogicalSize
-nsContainerFrame::ComputeAutoSize(nsRenderingContext* aRenderingContext,
+nsContainerFrame::ComputeAutoSize(gfxContext* aRenderingContext,
WritingMode aWM,
const LogicalSize& aCBSize,
nscoord aAvailableISize,
const LogicalSize& aMargin,
const LogicalSize& aBorder,
const LogicalSize& aPadding,
ComputeSizeFlags aFlags)
{
--- a/layout/generic/nsContainerFrame.h
+++ b/layout/generic/nsContainerFrame.h
@@ -179,17 +179,17 @@ public:
// The SET_ASYNC indicates that the actual nsIWidget calls to sync the window
// properties should be done async.
enum {
SET_ASYNC = 0x01,
};
static void SyncWindowProperties(nsPresContext* aPresContext,
nsIFrame* aFrame,
nsView* aView,
- nsRenderingContext* aRC,
+ gfxContext* aRC,
uint32_t aFlags);
/**
* Converts the minimum and maximum sizes given in inner window app units to
* outer window device pixel sizes and assigns these constraints to the widget.
*
* @param aPresContext pres context
* @param aWidget widget for this frame
@@ -197,26 +197,26 @@ public:
* @param maxmimum size of the window in app units
*/
static void SetSizeConstraints(nsPresContext* aPresContext,
nsIWidget* aWidget,
const nsSize& aMinSize,
const nsSize& aMaxSize);
// Used by both nsInlineFrame and nsFirstLetterFrame.
- void DoInlineIntrinsicISize(nsRenderingContext *aRenderingContext,
+ void DoInlineIntrinsicISize(gfxContext *aRenderingContext,
InlineIntrinsicISizeData *aData,
nsLayoutUtils::IntrinsicISizeType aType);
/**
* This is the CSS block concept of computing 'auto' widths, which most
* classes derived from nsContainerFrame want.
*/
virtual mozilla::LogicalSize
- ComputeAutoSize(nsRenderingContext* aRenderingContext,
+ ComputeAutoSize(gfxContext* aRenderingContext,
mozilla::WritingMode aWM,
const mozilla::LogicalSize& aCBSize,
nscoord aAvailableISize,
const mozilla::LogicalSize& aMargin,
const mozilla::LogicalSize& aBorder,
const mozilla::LogicalSize& aPadding,
ComputeSizeFlags aFlags) override;
--- a/layout/generic/nsFirstLetterFrame.cpp
+++ b/layout/generic/nsFirstLetterFrame.cpp
@@ -100,49 +100,49 @@ nsFirstLetterFrame::GetChildFrameContain
} else {
return nsFrame::GetChildFrameContainingOffset(inContentOffset, inHint, outFrameContentOffset, outChildFrame);
}
}
// Needed for non-floating first-letter frames and for the continuations
// following the first-letter that we also use nsFirstLetterFrame for.
/* virtual */ void
-nsFirstLetterFrame::AddInlineMinISize(nsRenderingContext *aRenderingContext,
+nsFirstLetterFrame::AddInlineMinISize(gfxContext *aRenderingContext,
nsIFrame::InlineMinISizeData *aData)
{
DoInlineIntrinsicISize(aRenderingContext, aData, nsLayoutUtils::MIN_ISIZE);
}
// Needed for non-floating first-letter frames and for the continuations
// following the first-letter that we also use nsFirstLetterFrame for.
/* virtual */ void
-nsFirstLetterFrame::AddInlinePrefISize(nsRenderingContext *aRenderingContext,
+nsFirstLetterFrame::AddInlinePrefISize(gfxContext *aRenderingContext,
nsIFrame::InlinePrefISizeData *aData)
{
DoInlineIntrinsicISize(aRenderingContext, aData, nsLayoutUtils::PREF_ISIZE);
aData->mLineIsEmpty = false;
}
// Needed for floating first-letter frames.
/* virtual */ nscoord
-nsFirstLetterFrame::GetMinISize(nsRenderingContext *aRenderingContext)
+nsFirstLetterFrame::GetMinISize(gfxContext *aRenderingContext)
{
return nsLayoutUtils::MinISizeFromInline(this, aRenderingContext);
}
// Needed for floating first-letter frames.
/* virtual */ nscoord
-nsFirstLetterFrame::GetPrefISize(nsRenderingContext *aRenderingContext)
+nsFirstLetterFrame::GetPrefISize(gfxContext *aRenderingContext)
{
return nsLayoutUtils::PrefISizeFromInline(this, aRenderingContext);
}
/* virtual */
LogicalSize
-nsFirstLetterFrame::ComputeSize(nsRenderingContext *aRenderingContext,
+nsFirstLetterFrame::ComputeSize(gfxContext *aRenderingContext,
WritingMode aWM,
const LogicalSize& aCBSize,
nscoord aAvailableISize,
const LogicalSize& aMargin,
const LogicalSize& aBorder,
const LogicalSize& aPadding,
ComputeSizeFlags aFlags)
{
--- a/layout/generic/nsFirstLetterFrame.h
+++ b/layout/generic/nsFirstLetterFrame.h
@@ -38,25 +38,25 @@ public:
virtual bool IsFrameOfType(uint32_t aFlags) const override
{
if (!IsFloating())
aFlags = aFlags & ~(nsIFrame::eLineParticipant);
return nsContainerFrame::IsFrameOfType(aFlags &
~(nsIFrame::eBidiInlineContainer));
}
- virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override;
- virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override;
- virtual void AddInlineMinISize(nsRenderingContext *aRenderingContext,
+ virtual nscoord GetMinISize(gfxContext *aRenderingContext) override;
+ virtual nscoord GetPrefISize(gfxContext *aRenderingContext) override;
+ virtual void AddInlineMinISize(gfxContext *aRenderingContext,
InlineMinISizeData *aData) override;
- virtual void AddInlinePrefISize(nsRenderingContext *aRenderingContext,
+ virtual void AddInlinePrefISize(gfxContext *aRenderingContext,
InlinePrefISizeData *aData) override;
virtual mozilla::LogicalSize
- ComputeSize(nsRenderingContext *aRenderingContext,
+ ComputeSize(gfxContext *aRenderingContext,
mozilla::WritingMode aWritingMode,
const mozilla::LogicalSize& aCBSize,
nscoord aAvailableISize,
const mozilla::LogicalSize& aMargin,
const mozilla::LogicalSize& aBorder,
const mozilla::LogicalSize& aPadding,
ComputeSizeFlags aFlags) override;
--- a/layout/generic/nsFlexContainerFrame.cpp
+++ b/layout/generic/nsFlexContainerFrame.cpp
@@ -10,21 +10,21 @@
#include "nsFlexContainerFrame.h"
#include "nsContentUtils.h"
#include "nsCSSAnonBoxes.h"
#include "nsDisplayList.h"
#include "nsIFrameInlines.h"
#include "nsLayoutUtils.h"
#include "nsPlaceholderFrame.h"
#include "nsPresContext.h"
-#include "nsRenderingContext.h"
#include "nsStyleContext.h"
#include "mozilla/CSSOrderAwareFrameIterator.h"
#include "mozilla/Logging.h"
#include <algorithm>
+#include "gfxContext.h"
#include "mozilla/LinkedList.h"
#include "mozilla/FloatingPoint.h"
#include "mozilla/UniquePtr.h"
#include "WritingModes.h"
using namespace mozilla;
using namespace mozilla::layout;
@@ -4626,17 +4626,17 @@ nsFlexContainerFrame::ReflowPlaceholders
// Mark the placeholder frame to indicate that it's not actually at the
// element's static position, because we need to apply CSS Alignment after
// we determine the OOF's size:
placeholder->AddStateBits(PLACEHOLDER_STATICPOS_NEEDS_CSSALIGN);
}
}
/* virtual */ nscoord
-nsFlexContainerFrame::GetMinISize(nsRenderingContext* aRenderingContext)
+nsFlexContainerFrame::GetMinISize(gfxContext* aRenderingContext)
{
nscoord minISize = 0;
DISPLAY_MIN_WIDTH(this, minISize);
RenumberList();
const nsStylePosition* stylePos = StylePosition();
const FlexboxAxisTracker axisTracker(this, GetWritingMode());
@@ -4656,17 +4656,17 @@ nsFlexContainerFrame::GetMinISize(nsRend
} else {
minISize = std::max(minISize, childMinISize);
}
}
return minISize;
}
/* virtual */ nscoord
-nsFlexContainerFrame::GetPrefISize(nsRenderingContext* aRenderingContext)
+nsFlexContainerFrame::GetPrefISize(gfxContext* aRenderingContext)
{
nscoord prefISize = 0;
DISPLAY_PREF_WIDTH(this, prefISize);
RenumberList();
// XXXdholbert Optimization: We could cache our intrinsic widths like
// nsBlockFrame does (and return it early from this function if it's set).
--- a/layout/generic/nsFlexContainerFrame.h
+++ b/layout/generic/nsFlexContainerFrame.h
@@ -69,18 +69,18 @@ public:
void MarkIntrinsicISizesDirty() override;
void Reflow(nsPresContext* aPresContext,
ReflowOutput& aDesiredSize,
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus) override;
- nscoord GetMinISize(nsRenderingContext* aRenderingContext) override;
- nscoord GetPrefISize(nsRenderingContext* aRenderingContext) override;
+ nscoord GetMinISize(gfxContext* aRenderingContext) override;
+ nscoord GetPrefISize(gfxContext* aRenderingContext) override;
#ifdef DEBUG_FRAME_DUMP
nsresult GetFrameName(nsAString& aResult) const override;
#endif
nscoord GetLogicalBaseline(mozilla::WritingMode aWM) const override;
bool GetVerticalAlignBaseline(mozilla::WritingMode aWM,
--- a/layout/generic/nsFrame.cpp
+++ b/layout/generic/nsFrame.cpp
@@ -77,17 +77,16 @@
#include "nsSVGIntegrationUtils.h"
#include "nsSVGEffects.h"
#include "nsChangeHint.h"
#include "nsDeckFrame.h"
#include "nsSubDocumentFrame.h"
#include "SVGTextFrame.h"
#include "gfxContext.h"
-#include "nsRenderingContext.h"
#include "nsAbsoluteContainingBlock.h"
#include "StickyScrollContainer.h"
#include "nsFontInflationData.h"
#include "nsRegion.h"
#include "nsIFrameInlines.h"
#include "nsStyleChangeList.h"
#include "mozilla/AsyncEventDispatcher.h"
@@ -1952,24 +1951,24 @@ public:
}
#ifdef NS_BUILD_REFCNT_LOGGING
virtual ~nsDisplaySelectionOverlay() {
MOZ_COUNT_DTOR(nsDisplaySelectionOverlay);
}
#endif
virtual void Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) override;
+ gfxContext* aCtx) override;
NS_DISPLAY_DECL_NAME("SelectionOverlay", TYPE_SELECTION_OVERLAY)
private:
int16_t mSelectionValue;
};
void nsDisplaySelectionOverlay::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx)
+ gfxContext* aCtx)
{
DrawTarget& aDrawTarget = *aCtx->GetDrawTarget();
LookAndFeel::ColorID colorID;
if (mSelectionValue == nsISelectionController::SELECTION_ON) {
colorID = LookAndFeel::eColorID_TextSelectBackground;
} else if (mSelectionValue == nsISelectionController::SELECTION_ATTENTION) {
colorID = LookAndFeel::eColorID_TextSelectBackgroundAttention;
@@ -4716,42 +4715,42 @@ nsFrame::MarkIntrinsicISizesDirty()
}
if (GetStateBits() & NS_FRAME_FONT_INFLATION_FLOW_ROOT) {
nsFontInflationData::MarkFontInflationDataTextDirty(this);
}
}
/* virtual */ nscoord
-nsFrame::GetMinISize(nsRenderingContext *aRenderingContext)
+nsFrame::GetMinISize(gfxContext *aRenderingContext)
{
nscoord result = 0;
DISPLAY_MIN_WIDTH(this, result);
return result;
}
/* virtual */ nscoord
-nsFrame::GetPrefISize(nsRenderingContext *aRenderingContext)
+nsFrame::GetPrefISize(gfxContext *aRenderingContext)
{
nscoord result = 0;
DISPLAY_PREF_WIDTH(this, result);
return result;
}
/* virtual */ void
-nsFrame::AddInlineMinISize(nsRenderingContext* aRenderingContext,
+nsFrame::AddInlineMinISize(gfxContext* aRenderingContext,
nsIFrame::InlineMinISizeData* aData)
{
nscoord isize = nsLayoutUtils::IntrinsicForContainer(aRenderingContext,
this, nsLayoutUtils::MIN_ISIZE);
aData->DefaultAddInlineMinISize(this, isize);
}
/* virtual */ void
-nsFrame::AddInlinePrefISize(nsRenderingContext* aRenderingContext,
+nsFrame::AddInlinePrefISize(gfxContext* aRenderingContext,
nsIFrame::InlinePrefISizeData* aData)
{
nscoord isize = nsLayoutUtils::IntrinsicForContainer(aRenderingContext,
this, nsLayoutUtils::PREF_ISIZE);
aData->DefaultAddInlinePrefISize(isize);
}
void
@@ -5040,17 +5039,17 @@ nsFrame::GetIntrinsicSize()
/* virtual */ nsSize
nsFrame::GetIntrinsicRatio()
{
return nsSize(0, 0);
}
/* virtual */
LogicalSize
-nsFrame::ComputeSize(nsRenderingContext* aRenderingContext,
+nsFrame::ComputeSize(gfxContext* aRenderingContext,
WritingMode aWM,
const LogicalSize& aCBSize,
nscoord aAvailableISize,
const LogicalSize& aMargin,
const LogicalSize& aBorder,
const LogicalSize& aPadding,
ComputeSizeFlags aFlags)
{
@@ -5301,17 +5300,17 @@ nsFrame::ComputeSize(nsRenderingContext*
result.ISize(aWM) = std::max(0, result.ISize(aWM));
result.BSize(aWM) = std::max(0, result.BSize(aWM));
return result;
}
LogicalSize
-nsFrame::ComputeSizeWithIntrinsicDimensions(nsRenderingContext* aRenderingContext,
+nsFrame::ComputeSizeWithIntrinsicDimensions(gfxContext* aRenderingContext,
WritingMode aWM,
const IntrinsicSize& aIntrinsicSize,
nsSize aIntrinsicRatio,
const LogicalSize& aCBSize,
const LogicalSize& aMargin,
const LogicalSize& aBorder,
const LogicalSize& aPadding,
ComputeSizeFlags aFlags)
@@ -5751,26 +5750,26 @@ nsFrame::ComputeSimpleTightBounds(DrawTa
nsIFrame* child = childFrames.get();
r.UnionRect(r, child->ComputeTightBounds(aDrawTarget) + child->GetPosition());
}
}
return r;
}
/* virtual */ nsresult
-nsIFrame::GetPrefWidthTightBounds(nsRenderingContext* aContext,
+nsIFrame::GetPrefWidthTightBounds(gfxContext* aContext,
nscoord* aX,
nscoord* aXMost)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* virtual */
LogicalSize
-nsFrame::ComputeAutoSize(nsRenderingContext* aRenderingContext,
+nsFrame::ComputeAutoSize(gfxContext* aRenderingContext,
WritingMode aWM,
const mozilla::LogicalSize& aCBSize,
nscoord aAvailableISize,
const mozilla::LogicalSize& aMargin,
const mozilla::LogicalSize& aBorder,
const mozilla::LogicalSize& aPadding,
ComputeSizeFlags aFlags)
{
@@ -5782,17 +5781,17 @@ nsFrame::ComputeAutoSize(nsRenderingCont
nscoord availBased = aAvailableISize - aMargin.ISize(aWM) -
aBorder.ISize(aWM) - aPadding.ISize(aWM);
result.ISize(aWM) = ShrinkWidthToFit(aRenderingContext, availBased, aFlags);
}
return result;
}
nscoord
-nsFrame::ShrinkWidthToFit(nsRenderingContext* aRenderingContext,
+nsFrame::ShrinkWidthToFit(gfxContext* aRenderingContext,
nscoord aISizeInCB,
ComputeSizeFlags aFlags)
{
// If we're a container for font size inflation, then shrink
// wrapping inside of us should not apply font size inflation.
AutoMaybeDisableFontInflation an(this);
nscoord result;
@@ -5807,17 +5806,17 @@ nsFrame::ShrinkWidthToFit(nsRenderingCon
} else {
result = prefISize;
}
}
return result;
}
nscoord
-nsIFrame::ComputeISizeValue(nsRenderingContext* aRenderingContext,
+nsIFrame::ComputeISizeValue(gfxContext* aRenderingContext,
nscoord aContainingBlockISize,
nscoord aContentEdgeToBoxSizing,
nscoord aBoxSizingToMarginEdge,
const nsStyleCoord& aCoord,
ComputeSizeFlags aFlags)
{
NS_PRECONDITION(aRenderingContext, "non-null rendering context expected");
LAYOUT_WARN_IF_FALSE(aContainingBlockISize != NS_UNCONSTRAINEDSIZE,
@@ -9639,17 +9638,17 @@ nsFrame::RefreshSizeCache(nsBoxLayoutSta
// the minimum height;
// 3) Minimum size. This is a toughy. We can pass the block a flag asking for the max element
// size. That would give us the width. Unfortunately you can only ask for a maxElementSize
// during an incremental reflow. So on other reflows we will just have to use 0.
// The min height on the other hand is fairly easy we need to get the largest
// line height. This can be done with the line iterator.
// if we do have a rendering context
- nsRenderingContext* rendContext = aState.GetRenderingContext();
+ gfxContext* rendContext = aState.GetRenderingContext();
if (rendContext) {
nsPresContext* presContext = aState.PresContext();
// If we don't have any HTML constraints and it's a resize, then nothing in the block
// could have changed, so no refresh is necessary.
nsBoxLayoutMetrics* metrics = BoxMetrics();
if (!DoesNeedRecalc(metrics->mBlockPrefSize))
return NS_OK;
@@ -9854,17 +9853,17 @@ nsFrame::GetXULBoxAscent(nsBoxLayoutStat
return metrics->mAscent;
}
nsresult
nsFrame::DoXULLayout(nsBoxLayoutState& aState)
{
nsRect ourRect(mRect);
- nsRenderingContext* rendContext = aState.GetRenderingContext();
+ gfxContext* rendContext = aState.GetRenderingContext();
nsPresContext* presContext = aState.PresContext();
WritingMode ourWM = GetWritingMode();
const WritingMode outerWM = aState.OuterReflowInput() ?
aState.OuterReflowInput()->GetWritingMode() : ourWM;
ReflowOutput desiredSize(outerWM);
LogicalSize ourSize = GetLogicalSize(outerWM);
if (rendContext) {
@@ -9935,17 +9934,17 @@ nsFrame::DoXULLayout(nsBoxLayoutState& a
return NS_OK;
}
void
nsFrame::BoxReflow(nsBoxLayoutState& aState,
nsPresContext* aPresContext,
ReflowOutput& aDesiredSize,
- nsRenderingContext* aRenderingContext,
+ gfxContext* aRenderingContext,
nscoord aX,
nscoord aY,
nscoord aWidth,
nscoord aHeight,
bool aMoveFrame)
{
DO_GLOBAL_REFLOW_COUNT("nsBoxToBlockAdaptor");
--- a/layout/generic/nsFrame.h
+++ b/layout/generic/nsFrame.h
@@ -260,43 +260,43 @@ public:
* style context should be the root of the style context tree.
*/
nsStyleContext* DoGetParentStyleContext(nsIFrame** aProviderFrame) const;
bool IsEmpty() override;
bool IsSelfEmpty() override;
void MarkIntrinsicISizesDirty() override;
- nscoord GetMinISize(nsRenderingContext *aRenderingContext) override;
- nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override;
- void AddInlineMinISize(nsRenderingContext *aRenderingContext,
+ nscoord GetMinISize(gfxContext *aRenderingContext) override;
+ nscoord GetPrefISize(gfxContext *aRenderingContext) override;
+ void AddInlineMinISize(gfxContext *aRenderingContext,
InlineMinISizeData *aData) override;
- void AddInlinePrefISize(nsRenderingContext *aRenderingContext,
+ void AddInlinePrefISize(gfxContext *aRenderingContext,
InlinePrefISizeData *aData) override;
IntrinsicISizeOffsetData IntrinsicISizeOffsets() override;
mozilla::IntrinsicSize GetIntrinsicSize() override;
nsSize GetIntrinsicRatio() override;
mozilla::LogicalSize
- ComputeSize(nsRenderingContext* aRenderingContext,
+ ComputeSize(gfxContext* aRenderingContext,
mozilla::WritingMode aWM,
const mozilla::LogicalSize& aCBSize,
nscoord aAvailableISize,
const mozilla::LogicalSize& aMargin,
const mozilla::LogicalSize& aBorder,
const mozilla::LogicalSize& aPadding,
ComputeSizeFlags aFlags) override;
/**
* Calculate the used values for 'width' and 'height' for a replaced element.
* http://www.w3.org/TR/CSS21/visudet.html#min-max-widths
*/
mozilla::LogicalSize
ComputeSizeWithIntrinsicDimensions(
- nsRenderingContext* aRenderingContext,
+ gfxContext* aRenderingContext,
mozilla::WritingMode aWM,
const mozilla::IntrinsicSize& aIntrinsicSize,
nsSize aIntrinsicRatio,
const mozilla::LogicalSize& aCBSize,
const mozilla::LogicalSize& aMargin,
const mozilla::LogicalSize& aBorder,
const mozilla::LogicalSize& aPadding,
ComputeSizeFlags aFlags);
@@ -316,30 +316,30 @@ public:
* override ComputeSize to enforce their width/height invariants.
*
* Implementations may optimize by returning a garbage width if
* StylePosition()->mWidth.GetUnit() != eStyleUnit_Auto, and
* likewise for height, since in such cases the result is guaranteed
* to be unused.
*/
virtual mozilla::LogicalSize
- ComputeAutoSize(nsRenderingContext* aRenderingContext,
+ ComputeAutoSize(gfxContext* aRenderingContext,
mozilla::WritingMode aWM,
const mozilla::LogicalSize& aCBSize,
nscoord aAvailableISize,
const mozilla::LogicalSize& aMargin,
const mozilla::LogicalSize& aBorder,
const mozilla::LogicalSize& aPadding,
ComputeSizeFlags aFlags);
/**
* Utility function for ComputeAutoSize implementations. Return
* max(GetMinISize(), min(aISizeInCB, GetPrefISize()))
*/
- nscoord ShrinkWidthToFit(nsRenderingContext* aRenderingContext,
+ nscoord ShrinkWidthToFit(gfxContext* aRenderingContext,
nscoord aISizeInCB,
ComputeSizeFlags aFlags);
/**
* Calculates the size of this frame after reflowing (calling Reflow on, and
* updating the size and position of) its children, as necessary. The
* calculated size is returned to the caller via the ReflowOutput
* outparam. (The caller is responsible for setting the actual size and
@@ -707,17 +707,17 @@ protected:
mozilla::ServoStyleSet& aStyleSet,
nsStyleChangeList& aChangeList,
nsChangeHint aHintForThisFrame);
private:
void BoxReflow(nsBoxLayoutState& aState,
nsPresContext* aPresContext,
ReflowOutput& aDesiredSize,
- nsRenderingContext* aRenderingContext,
+ gfxContext* aRenderingContext,
nscoord aX,
nscoord aY,
nscoord aWidth,
nscoord aHeight,
bool aMoveFrame = true);
NS_IMETHODIMP RefreshSizeCache(nsBoxLayoutState& aState);
--- a/layout/generic/nsFrameSetFrame.cpp
+++ b/layout/generic/nsFrameSetFrame.cpp
@@ -20,17 +20,16 @@
#include "nsContainerFrame.h"
#include "nsLayoutUtils.h"
#include "nsPresContext.h"
#include "nsIPresShell.h"
#include "nsGkAtoms.h"
#include "nsStyleConsts.h"
#include "nsStyleContext.h"
#include "nsHTMLParts.h"
-#include "nsRenderingContext.h"
#include "nsIDOMMutationEvent.h"
#include "nsNameSpaceManager.h"
#include "nsCSSAnonBoxes.h"
#include "mozilla/StyleSetHandle.h"
#include "mozilla/StyleSetHandleInlines.h"
#include "mozilla/dom/Element.h"
#include "nsDisplayList.h"
#include "nsNodeUtils.h"
@@ -1403,22 +1402,22 @@ public:
// REVIEW: see old GetFrameForPoint
// Receives events in its bounds
virtual void HitTest(nsDisplayListBuilder* aBuilder, const nsRect& aRect,
HitTestState* aState,
nsTArray<nsIFrame*> *aOutFrames) override {
aOutFrames->AppendElement(mFrame);
}
virtual void Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) override;
+ gfxContext* aCtx) override;
NS_DISPLAY_DECL_NAME("FramesetBorder", TYPE_FRAMESET_BORDER)
};
void nsDisplayFramesetBorder::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx)
+ gfxContext* aCtx)
{
static_cast<nsHTMLFramesetBorderFrame*>(mFrame)->
PaintBorder(aCtx->GetDrawTarget(), ToReferenceFrame());
}
void
nsHTMLFramesetBorderFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
@@ -1611,22 +1610,22 @@ public:
}
#ifdef NS_BUILD_REFCNT_LOGGING
virtual ~nsDisplayFramesetBlank() {
MOZ_COUNT_DTOR(nsDisplayFramesetBlank);
}
#endif
virtual void Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) override;
+ gfxContext* aCtx) override;
NS_DISPLAY_DECL_NAME("FramesetBlank", TYPE_FRAMESET_BLANK)
};
void nsDisplayFramesetBlank::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx)
+ gfxContext* aCtx)
{
DrawTarget* drawTarget = aCtx->GetDrawTarget();
int32_t appUnitsPerDevPixel = mFrame->PresContext()->AppUnitsPerDevPixel();
Rect rect =
NSRectToSnappedRect(mVisibleRect, appUnitsPerDevPixel, *drawTarget);
ColorPattern white(ToDeviceColor(Color(1.f, 1.f, 1.f, 1.f)));
drawTarget->FillRect(rect, white);
}
--- a/layout/generic/nsGfxScrollFrame.cpp
+++ b/layout/generic/nsGfxScrollFrame.cpp
@@ -773,41 +773,41 @@ nsHTMLScrollFrame::PlaceScrollArea(Scrol
nsContainerFrame::SyncFrameViewAfterReflow(scrolledFrame->PresContext(),
scrolledFrame,
scrolledFrame->GetView(),
scrolledArea,
0);
}
nscoord
-nsHTMLScrollFrame::GetIntrinsicVScrollbarWidth(nsRenderingContext *aRenderingContext)
+nsHTMLScrollFrame::GetIntrinsicVScrollbarWidth(gfxContext *aRenderingContext)
{
ScrollbarStyles ss = GetScrollbarStyles();
if (ss.mVertical != NS_STYLE_OVERFLOW_SCROLL || !mHelper.mVScrollbarBox)
return 0;
// Don't need to worry about reflow depth here since it's
// just for scrollbars
nsBoxLayoutState bls(PresContext(), aRenderingContext, 0);
nsSize vScrollbarPrefSize(0, 0);
GetScrollbarMetrics(bls, mHelper.mVScrollbarBox,
nullptr, &vScrollbarPrefSize, true);
return vScrollbarPrefSize.width;
}
/* virtual */ nscoord
-nsHTMLScrollFrame::GetMinISize(nsRenderingContext *aRenderingContext)
+nsHTMLScrollFrame::GetMinISize(gfxContext *aRenderingContext)
{
nscoord result = mHelper.mScrolledFrame->GetMinISize(aRenderingContext);
DISPLAY_MIN_WIDTH(this, result);
return result + GetIntrinsicVScrollbarWidth(aRenderingContext);
}
/* virtual */ nscoord
-nsHTMLScrollFrame::GetPrefISize(nsRenderingContext *aRenderingContext)
+nsHTMLScrollFrame::GetPrefISize(gfxContext *aRenderingContext)
{
nscoord result = mHelper.mScrolledFrame->GetPrefISize(aRenderingContext);
DISPLAY_PREF_WIDTH(this, result);
return NSCoordSaturatingAdd(result, GetIntrinsicVScrollbarWidth(aRenderingContext));
}
nsresult
nsHTMLScrollFrame::GetXULPadding(nsMargin& aMargin)
--- a/layout/generic/nsGfxScrollFrame.h
+++ b/layout/generic/nsGfxScrollFrame.h
@@ -699,25 +699,25 @@ public:
bool aAssumeHScroll,
bool aAssumeVScroll,
ReflowOutput* aMetrics,
bool aFirstPass);
void ReflowContents(ScrollReflowInput* aState,
const ReflowOutput& aDesiredSize);
void PlaceScrollArea(ScrollReflowInput& aState,
const nsPoint& aScrollPosition);
- nscoord GetIntrinsicVScrollbarWidth(nsRenderingContext *aRenderingContext);
+ nscoord GetIntrinsicVScrollbarWidth(gfxContext *aRenderingContext);
virtual bool GetBorderRadii(const nsSize& aFrameSize, const nsSize& aBorderArea,
Sides aSkipSides, nscoord aRadii[8]) const override {
return mHelper.GetBorderRadii(aFrameSize, aBorderArea, aSkipSides, aRadii);
}
- virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override;
- virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override;
+ virtual nscoord GetMinISize(gfxContext *aRenderingContext) override;
+ virtual nscoord GetPrefISize(gfxContext *aRenderingContext) override;
virtual nsresult GetXULPadding(nsMargin& aPadding) override;
virtual bool IsXULCollapsed() override;
virtual void Reflow(nsPresContext* aPresContext,
ReflowOutput& aDesiredSize,
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus) override;
@@ -784,22 +784,22 @@ public:
}
virtual nsMargin GetActualScrollbarSizes() const override {
return mHelper.GetActualScrollbarSizes();
}
virtual nsMargin GetDesiredScrollbarSizes(nsBoxLayoutState* aState) override {
return mHelper.GetDesiredScrollbarSizes(aState);
}
virtual nsMargin GetDesiredScrollbarSizes(nsPresContext* aPresContext,
- nsRenderingContext* aRC) override {
+ gfxContext* aRC) override {
nsBoxLayoutState bls(aPresContext, aRC, 0);
return GetDesiredScrollbarSizes(&bls);
}
virtual nscoord GetNondisappearingScrollbarWidth(nsPresContext* aPresContext,
- nsRenderingContext* aRC, mozilla::WritingMode aWM) override {
+ gfxContext* aRC, mozilla::WritingMode aWM) override {
nsBoxLayoutState bls(aPresContext, aRC, 0);
return mHelper.GetNondisappearingScrollbarWidth(&bls, aWM);
}
virtual nsRect GetScrolledRect() const override {
return mHelper.GetScrolledRect();
}
virtual nsRect GetScrollPortRect() const override {
return mHelper.GetScrollPortRect();
@@ -1121,17 +1121,17 @@ public:
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) override {
mHelper.BuildDisplayList(aBuilder, aDirtyRect, aLists);
}
// XXXldb Is this actually used?
#if 0
- virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override;
+ virtual nscoord GetMinISize(gfxContext *aRenderingContext) override;
#endif
virtual bool ComputeCustomOverflow(nsOverflowAreas& aOverflowAreas) override {
return mHelper.ComputeCustomOverflow(aOverflowAreas);
}
bool GetVerticalAlignBaseline(mozilla::WritingMode aWM,
nscoord* aBaseline) const override {
@@ -1225,22 +1225,22 @@ public:
}
virtual nsMargin GetActualScrollbarSizes() const override {
return mHelper.GetActualScrollbarSizes();
}
virtual nsMargin GetDesiredScrollbarSizes(nsBoxLayoutState* aState) override {
return mHelper.GetDesiredScrollbarSizes(aState);
}
virtual nsMargin GetDesiredScrollbarSizes(nsPresContext* aPresContext,
- nsRenderingContext* aRC) override {
+ gfxContext* aRC) override {
nsBoxLayoutState bls(aPresContext, aRC, 0);
return GetDesiredScrollbarSizes(&bls);
}
virtual nscoord GetNondisappearingScrollbarWidth(nsPresContext* aPresContext,
- nsRenderingContext* aRC, mozilla::WritingMode aWM) override {
+ gfxContext* aRC, mozilla::WritingMode aWM) override {
nsBoxLayoutState bls(aPresContext, aRC, 0);
return mHelper.GetNondisappearingScrollbarWidth(&bls, aWM);
}
virtual nsRect GetScrolledRect() const override {
return mHelper.GetScrolledRect();
}
virtual nsRect GetScrollPortRect() const override {
return mHelper.GetScrollPortRect();
--- a/layout/generic/nsGridContainerFrame.cpp
+++ b/layout/generic/nsGridContainerFrame.cpp
@@ -6,33 +6,33 @@
/* rendering object for CSS "display: grid | inline-grid" */
#include "nsGridContainerFrame.h"
#include <algorithm> // for std::stable_sort
#include <functional>
#include <limits>
+#include "gfxContext.h"
#include "mozilla/CSSAlignUtils.h"
#include "mozilla/CSSOrderAwareFrameIterator.h"
#include "mozilla/dom/GridBinding.h"
#include "mozilla/Maybe.h"
#include "mozilla/PodOperations.h" // for PodZero
#include "mozilla/Poison.h"
#include "nsAbsoluteContainingBlock.h"
#include "nsAlgorithm.h" // for clamped()
#include "nsCSSAnonBoxes.h"
#include "nsCSSFrameConstructor.h"
#include "nsDataHashtable.h"
#include "nsDisplayList.h"
#include "nsHashKeys.h"
#include "nsIFrameInlines.h"
#include "nsPresContext.h"
#include "nsReadableUtils.h"
-#include "nsRenderingContext.h"
#include "nsRuleNode.h"
#include "nsStyleContext.h"
#include "nsTableWrapperFrame.h"
using namespace mozilla;
typedef nsAbsoluteContainingBlock::AbsPosReflowFlags AbsPosReflowFlags;
typedef nsGridContainerFrame::TrackSize TrackSize;
@@ -1724,17 +1724,17 @@ struct nsGridContainerFrame::SharedGridD
struct MOZ_STACK_CLASS nsGridContainerFrame::GridReflowInput
{
GridReflowInput(nsGridContainerFrame* aFrame,
const ReflowInput& aRI)
: GridReflowInput(aFrame, *aRI.mRenderingContext, &aRI, aRI.mStylePosition,
aRI.GetWritingMode())
{}
GridReflowInput(nsGridContainerFrame* aFrame,
- nsRenderingContext& aRC)
+ gfxContext& aRC)
: GridReflowInput(aFrame, aRC, nullptr, aFrame->StylePosition(),
aFrame->GetWritingMode())
{}
/**
* Initialize our track sizes and grid item info using the shared
* state from aGridContainerFrame first-in-flow.
*/
@@ -1891,17 +1891,17 @@ struct MOZ_STACK_CLASS nsGridContainerFr
nsTArray<GridItemInfo> mAbsPosItems;
/**
* @note mReflowInput may be null when using the 2nd ctor above. In this case
* we'll construct a dummy parent reflow state if we need it to calculate
* min/max-content contributions when sizing tracks.
*/
const ReflowInput* const mReflowInput;
- nsRenderingContext& mRenderingContext;
+ gfxContext& mRenderingContext;
nsGridContainerFrame* const mFrame;
SharedGridData* mSharedGridData; // [weak] owned by mFrame's first-in-flow.
/** Computed border+padding with mSkipSides applied. */
LogicalMargin mBorderPadding;
/**
* BStart of this fragment in "grid space" (i.e. the concatenation of content
* areas of all fragments). Equal to mRows.mSizes[mStartRow].mPosition,
* or, if this fragment starts after the last row, the ConsumedBSize().
@@ -1917,17 +1917,17 @@ struct MOZ_STACK_CLASS nsGridContainerFr
/** Our tentative ApplySkipSides bits. */
LogicalSides mSkipSides;
const WritingMode mWM;
/** Initialized lazily, when we find the fragmentainer. */
bool mInFragmentainer;
private:
GridReflowInput(nsGridContainerFrame* aFrame,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
const ReflowInput* aReflowInput,
const nsStylePosition* aGridStyle,
const WritingMode& aWM)
: mIter(aFrame, kPrincipalList)
, mGridStyle(aGridStyle)
, mCols(eLogicalAxisInline)
, mRows(eLogicalAxisBlock)
, mColFunctions(mGridStyle->mGridTemplateColumns,
@@ -3441,17 +3441,17 @@ nsGridContainerFrame::Tracks::Initialize
}
/**
* Reflow aChild in the given aAvailableSize.
*/
static nscoord
MeasuringReflow(nsIFrame* aChild,
const ReflowInput* aReflowInput,
- nsRenderingContext* aRC,
+ gfxContext* aRC,
const LogicalSize& aAvailableSize,
const LogicalSize& aCBSize,
nscoord aIMinSizeClamp = NS_MAXSIZE,
nscoord aBMinSizeClamp = NS_MAXSIZE)
{
nsContainerFrame* parent = aChild->GetParent();
nsPresContext* pc = aChild->PresContext();
Maybe<ReflowInput> dummyParentState;
@@ -3510,17 +3510,17 @@ MeasuringReflow(nsIFrame* aChi
/**
* Return the [min|max]-content contribution of aChild to its parent (i.e.
* the child's margin-box) in aAxis.
*/
static nscoord
ContentContribution(const GridItemInfo& aGridItem,
const GridReflowInput& aState,
- nsRenderingContext* aRC,
+ gfxContext* aRC,
WritingMode aCBWM,
LogicalAxis aAxis,
const Maybe<LogicalSize>& aPercentageBasis,
IntrinsicISizeType aConstraint,
nscoord aMinSizeClamp = NS_MAXSIZE,
uint32_t aFlags = 0)
{
nsIFrame* child = aGridItem.mFrame;
@@ -3607,17 +3607,17 @@ struct CachedIntrinsicSizes
// https://drafts.csswg.org/css-grid/#min-size-auto
// This is the clamp value to use for that:
nscoord mMinSizeClamp = NS_MAXSIZE;
};
static nscoord
MinContentContribution(const GridItemInfo& aGridItem,
const GridReflowInput& aState,
- nsRenderingContext* aRC,
+ gfxContext* aRC,
WritingMode aCBWM,
LogicalAxis aAxis,
CachedIntrinsicSizes* aCache)
{
if (aCache->mMinContentContribution.isSome()) {
return aCache->mMinContentContribution.value();
}
if (aCache->mPercentageBasis.isNothing()) {
@@ -3629,17 +3629,17 @@ MinContentContribution(const GridItemInf
aCache->mMinSizeClamp);
aCache->mMinContentContribution.emplace(s);
return s;
}
static nscoord
MaxContentContribution(const GridItemInfo& aGridItem,
const GridReflowInput& aState,
- nsRenderingContext* aRC,
+ gfxContext* aRC,
WritingMode aCBWM,
LogicalAxis aAxis,
CachedIntrinsicSizes* aCache)
{
if (aCache->mMaxContentContribution.isSome()) {
return aCache->mMaxContentContribution.value();
}
if (aCache->mPercentageBasis.isNothing()) {
@@ -3653,17 +3653,17 @@ MaxContentContribution(const GridItemInf
return s;
}
// Computes the min-size contribution for a grid item, as defined at
// https://drafts.csswg.org/css-grid/#min-size-contributions
static nscoord
MinSize(const GridItemInfo& aGridItem,
const GridReflowInput& aState,
- nsRenderingContext* aRC,
+ gfxContext* aRC,
WritingMode aCBWM,
LogicalAxis aAxis,
CachedIntrinsicSizes* aCache)
{
if (aCache->mMinSize.isSome()) {
return aCache->mMinSize.value();
}
nsIFrame* child = aGridItem.mFrame;
@@ -3783,17 +3783,17 @@ nsGridContainerFrame::Tracks::ResolveInt
if (sz.mState & TrackSize::eIntrinsicMinSizing) {
auto maxCoord = aFunctions.MaxSizingFor(aRange.mStart);
cache.mMinSizeClamp =
nsRuleNode::ComputeCoordPercentCalc(maxCoord, aPercentageBasis);
}
aGridItem.mState[mAxis] |= ItemState::eClampMarginBoxMinSize;
}
// min sizing
- nsRenderingContext* rc = &aState.mRenderingContext;
+ gfxContext* rc = &aState.mRenderingContext;
if (sz.mState & TrackSize::eAutoMinSizing) {
nscoord s;
if (aConstraint == SizingConstraint::eMinContent) {
s = MinContentContribution(aGridItem, aState, rc, wm, mAxis, &cache);
} else if (aConstraint == SizingConstraint::eMaxContent) {
s = MaxContentContribution(aGridItem, aState, rc, wm, mAxis, &cache);
} else {
MOZ_ASSERT(aConstraint == SizingConstraint::eNoConstraint);
@@ -4162,17 +4162,17 @@ nsGridContainerFrame::Tracks::ResolveInt
// Resolve Intrinsic Track Sizes
// http://dev.w3.org/csswg/css-grid/#algo-content
// We're also setting eIsFlexing on the item state here to speed up
// FindUsedFlexFraction later.
AutoTArray<TrackSize::StateBits, 16> stateBitsPerSpan;
nsTArray<Step2ItemData> step2Items;
CSSOrderAwareFrameIterator& iter = aState.mIter;
- nsRenderingContext* rc = &aState.mRenderingContext;
+ gfxContext* rc = &aState.mRenderingContext;
WritingMode wm = aState.mWM;
uint32_t maxSpan = 0; // max span of the step2Items items
// Setup track selector for step 2.2:
const auto contentBasedMinSelector =
aConstraint == SizingConstraint::eMinContent ?
TrackSize::eIntrinsicMinSizing : TrackSize::eMinOrMaxContentMinSizing;
// Setup track selector for step 2.3:
const auto maxContentMinSelector =
@@ -4504,17 +4504,17 @@ nsGridContainerFrame::Tracks::FindUsedFl
for (uint32_t track : aFlexTracks) {
float flexFactor = aFunctions.MaxSizingFor(track).GetFlexFractionValue();
float possiblyDividedBaseSize = (flexFactor > 1.0f)
? mSizes[track].mBase / flexFactor
: mSizes[track].mBase;
fr = std::max(fr, possiblyDividedBaseSize);
}
WritingMode wm = aState.mWM;
- nsRenderingContext* rc = &aState.mRenderingContext;
+ gfxContext* rc = &aState.mRenderingContext;
CSSOrderAwareFrameIterator& iter = aState.mIter;
iter.Reset();
// ... the result of 'finding the size of an fr' for each item that spans
// a flex track with its max-content contribution as 'space to fill'
for (; !iter.AtEnd(); iter.Next()) {
const GridItemInfo& item = aGridItems[iter.ItemIndex()];
if (item.mState[mAxis] & ItemState::eIsFlexing) {
// XXX optimize: bug 1194446
@@ -6299,17 +6299,17 @@ nsGridContainerFrame::Reflow(nsPresConte
}
}
FinishAndStoreOverflow(&aDesiredSize);
NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
}
nscoord
-nsGridContainerFrame::IntrinsicISize(nsRenderingContext* aRenderingContext,
+nsGridContainerFrame::IntrinsicISize(gfxContext* aRenderingContext,
IntrinsicISizeType aType)
{
RenumberList();
// Calculate the sum of column sizes under intrinsic sizing.
// http://dev.w3.org/csswg/css-grid/#intrinsic-sizes
GridReflowInput state(this, *aRenderingContext);
InitImplicitNamedAreas(state.mGridStyle); // XXX optimize
@@ -6368,27 +6368,27 @@ nsGridContainerFrame::IntrinsicISize(nsR
state.mCols.CalculateSizes(state, state.mGridItems, state.mColFunctions,
NS_UNCONSTRAINEDSIZE, &GridArea::mCols,
constraint);
return state.mCols.BackComputedIntrinsicSize(state.mColFunctions,
state.mGridStyle->mGridColumnGap);
}
nscoord
-nsGridContainerFrame::GetMinISize(nsRenderingContext* aRC)
+nsGridContainerFrame::GetMinISize(gfxContext* aRC)
{
DISPLAY_MIN_WIDTH(this, mCachedMinISize);
if (mCachedMinISize == NS_INTRINSIC_WIDTH_UNKNOWN) {
mCachedMinISize = IntrinsicISize(aRC, nsLayoutUtils::MIN_ISIZE);
}
return mCachedMinISize;
}
nscoord
-nsGridContainerFrame::GetPrefISize(nsRenderingContext* aRC)
+nsGridContainerFrame::GetPrefISize(gfxContext* aRC)
{
DISPLAY_PREF_WIDTH(this, mCachedPrefISize);
if (mCachedPrefISize == NS_INTRINSIC_WIDTH_UNKNOWN) {
mCachedPrefISize = IntrinsicISize(aRC, nsLayoutUtils::PREF_ISIZE);
}
return mCachedPrefISize;
}
--- a/layout/generic/nsGridContainerFrame.h
+++ b/layout/generic/nsGridContainerFrame.h
@@ -89,18 +89,18 @@ public:
typedef mozilla::ComputedGridTrackInfo ComputedGridTrackInfo;
typedef mozilla::ComputedGridLineInfo ComputedGridLineInfo;
// nsIFrame overrides
void Reflow(nsPresContext* aPresContext,
ReflowOutput& aDesiredSize,
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus) override;
- nscoord GetMinISize(nsRenderingContext* aRenderingContext) override;
- nscoord GetPrefISize(nsRenderingContext* aRenderingContext) override;
+ nscoord GetMinISize(gfxContext* aRenderingContext) override;
+ nscoord GetPrefISize(gfxContext* aRenderingContext) override;
void MarkIntrinsicISizesDirty() override;
bool IsFrameOfType(uint32_t aFlags) const override
{
return nsContainerFrame::IsFrameOfType(aFlags &
~nsIFrame::eCanContainOverflowContainers);
}
void BuildDisplayList(nsDisplayListBuilder* aBuilder,
@@ -284,17 +284,17 @@ protected:
nscoord ReflowChildren(GridReflowInput& aState,
const LogicalRect& aContentArea,
ReflowOutput& aDesiredSize,
nsReflowStatus& aStatus);
/**
* Helper for GetMinISize / GetPrefISize.
*/
- nscoord IntrinsicISize(nsRenderingContext* aRenderingContext,
+ nscoord IntrinsicISize(gfxContext* aRenderingContext,
IntrinsicISizeType aConstraint);
// Helper for AppendFrames / InsertFrames.
void NoteNewChildren(ChildListID aListID, const nsFrameList& aFrameList);
// Helper to move child frames into the kOverflowList.
void MergeSortedOverflow(nsFrameList& aList);
// Helper to move child frames into the kExcessOverflowContainersList:.
--- a/layout/generic/nsHTMLCanvasFrame.cpp
+++ b/layout/generic/nsHTMLCanvasFrame.cpp
@@ -177,29 +177,29 @@ nsHTMLCanvasFrame::GetCanvasSize()
} else {
NS_NOTREACHED("couldn't get canvas size");
}
return size;
}
/* virtual */ nscoord
-nsHTMLCanvasFrame::GetMinISize(nsRenderingContext *aRenderingContext)
+nsHTMLCanvasFrame::GetMinISize(gfxContext *aRenderingContext)
{
// XXX The caller doesn't account for constraints of the height,
// min-height, and max-height properties.
bool vertical = GetWritingMode().IsVertical();
nscoord result = nsPresContext::CSSPixelsToAppUnits(
vertical ? GetCanvasSize().height : GetCanvasSize().width);
DISPLAY_MIN_WIDTH(this, result);
return result;
}
/* virtual */ nscoord
-nsHTMLCanvasFrame::GetPrefISize(nsRenderingContext *aRenderingContext)
+nsHTMLCanvasFrame::GetPrefISize(gfxContext *aRenderingContext)
{
// XXX The caller doesn't account for constraints of the height,
// min-height, and max-height properties.
bool vertical = GetWritingMode().IsVertical();
nscoord result = nsPresContext::CSSPixelsToAppUnits(
vertical ? GetCanvasSize().height : GetCanvasSize().width);
DISPLAY_PREF_WIDTH(this, result);
return result;
@@ -214,17 +214,17 @@ nsHTMLCanvasFrame::GetIntrinsicSize()
/* virtual */ nsSize
nsHTMLCanvasFrame::GetIntrinsicRatio()
{
return IntrinsicRatioFromCanvasSize(GetCanvasSize());
}
/* virtual */
LogicalSize
-nsHTMLCanvasFrame::ComputeSize(nsRenderingContext *aRenderingContext,
+nsHTMLCanvasFrame::ComputeSize(gfxContext *aRenderingContext,
WritingMode aWM,
const LogicalSize& aCBSize,
nscoord aAvailableISize,
const LogicalSize& aMargin,
const LogicalSize& aBorder,
const LogicalSize& aPadding,
ComputeSizeFlags aFlags)
{
--- a/layout/generic/nsHTMLCanvasFrame.h
+++ b/layout/generic/nsHTMLCanvasFrame.h
@@ -51,23 +51,23 @@ public:
already_AddRefed<Layer> BuildLayer(nsDisplayListBuilder* aBuilder,
LayerManager* aManager,
nsDisplayItem* aItem,
const ContainerLayerParameters& aContainerParameters);
/* get the size of the canvas's image */
nsIntSize GetCanvasSize();
- virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override;
- virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override;
+ virtual nscoord GetMinISize(gfxContext *aRenderingContext) override;
+ virtual nscoord GetPrefISize(gfxContext *aRenderingContext) override;
virtual mozilla::IntrinsicSize GetIntrinsicSize() override;
virtual nsSize GetIntrinsicRatio() override;
virtual mozilla::LogicalSize
- ComputeSize(nsRenderingContext *aRenderingContext,
+ ComputeSize(gfxContext *aRenderingContext,
mozilla::WritingMode aWritingMode,
const mozilla::LogicalSize& aCBSize,
nscoord aAvailableISize,
const mozilla::LogicalSize& aMargin,
const mozilla::LogicalSize& aBorder,
const mozilla::LogicalSize& aPadding,
ComputeSizeFlags aFlags) override;
--- a/layout/generic/nsIFrame.h
+++ b/layout/generic/nsIFrame.h
@@ -61,17 +61,16 @@
* entire line, for example, but the frame should still be positioned and sized (and
* the view sized) during the reflow (i.e., before sending the DidReflow() notification)
* 5. the view system handles moving of widgets, i.e., it's not our problem
*/
class nsIAtom;
class nsPresContext;
class nsIPresShell;
-class nsRenderingContext;
class nsView;
class nsIWidget;
class nsISelectionController;
class nsBoxLayoutState;
class nsBoxLayout;
class nsILineIterator;
class nsDisplayListBuilder;
class nsDisplayListSet;
@@ -2098,25 +2097,25 @@ public:
* Note that many frames will cache the result of this function call
* unless MarkIntrinsicISizesDirty is called.
*
* It is not acceptable for a frame to mark itself dirty when this
* method is called.
*
* This method must not return a negative value.
*/
- virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) = 0;
+ virtual nscoord GetMinISize(gfxContext *aRenderingContext) = 0;
/**
* Get the max-content intrinsic inline size of the frame. This must be
* greater than or equal to the min-content intrinsic inline size.
*
* Otherwise, all the comments for |GetMinISize| above apply.
*/
- virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) = 0;
+ virtual nscoord GetPrefISize(gfxContext *aRenderingContext) = 0;
/**
* |InlineIntrinsicISize| represents the intrinsic width information
* in inline layout. Code that determines the intrinsic width of a
* region of inline layout accumulates the result into this structure.
* This pattern is needed because we need to maintain state
* information about whitespace (for both collapsing and trimming).
*/
@@ -2265,31 +2264,31 @@ public:
* is responsible for adding padding, border, and margin and for
* considering the effects of 'width', 'min-width', and 'max-width'.
*
* This may be called on any frame. Frames that do not participate in
* line breaking can inherit the default implementation on nsFrame,
* which calls |GetMinISize|.
*/
virtual void
- AddInlineMinISize(nsRenderingContext *aRenderingContext,
+ AddInlineMinISize(gfxContext *aRenderingContext,
InlineMinISizeData *aData) = 0;
/**
* Add the intrinsic preferred width of a frame in a way suitable for
* use in inline layout to an |InlineIntrinsicISizeData| object that
* represents the intrinsic width information of all the previous
* frames in the inline layout region.
*
* All the comments for |AddInlineMinISize| and |GetPrefISize| apply,
* except that this fills in an |InlineIntrinsicISizeData| structure
* based on using all *mandatory* breakpoints within the frame.
*/
virtual void
- AddInlinePrefISize(nsRenderingContext *aRenderingContext,
+ AddInlinePrefISize(gfxContext *aRenderingContext,
InlinePrefISizeData *aData) = 0;
/**
* Return the horizontal components of padding, border, and margin
* that contribute to the intrinsic width that applies to the parent.
*/
struct IntrinsicISizeOffsetData {
nscoord hPadding, hBorder, hMargin;
@@ -2391,17 +2390,17 @@ public:
* @param aBorder The sum of the vertical / horizontal border widths
* of the frame.
* @param aPadding The sum of the vertical / horizontal margins of
* the frame, including actual values resulting from
* percentages.
* @param aFlags Flags to further customize behavior (definitions above).
*/
virtual mozilla::LogicalSize
- ComputeSize(nsRenderingContext *aRenderingContext,
+ ComputeSize(gfxContext *aRenderingContext,
mozilla::WritingMode aWritingMode,
const mozilla::LogicalSize& aCBSize,
nscoord aAvailableISize,
const mozilla::LogicalSize& aMargin,
const mozilla::LogicalSize& aBorder,
const mozilla::LogicalSize& aPadding,
ComputeSizeFlags aFlags) = 0;
@@ -2431,17 +2430,17 @@ public:
* elements.
* @param aContext a rendering context that can be used if we need
* to do measurement
* @param aX computed left coordinate of the tight bounding rectangle
* @param aXMost computed intrinsic width of the tight bounding rectangle
*
*/
- virtual nsresult GetPrefWidthTightBounds(nsRenderingContext* aContext,
+ virtual nsresult GetPrefWidthTightBounds(gfxContext* aContext,
nscoord* aX,
nscoord* aXMost);
/**
* The frame is given an available size and asked for its desired
* size. This is the frame's opportunity to reflow its children.
*
* If the frame has the NS_FRAME_IS_DIRTY bit set then it is
@@ -3873,17 +3872,17 @@ public:
virtual bool RenumberFrameAndDescendants(int32_t* aOrdinal,
int32_t aDepth,
int32_t aIncrement,
bool aForCounting) { return false; }
/**
* Helper function - computes the content-box inline size for aCoord.
*/
- nscoord ComputeISizeValue(nsRenderingContext* aRenderingContext,
+ nscoord ComputeISizeValue(gfxContext* aRenderingContext,
nscoord aContainingBlockISize,
nscoord aContentEdgeToBoxSizing,
nscoord aBoxSizingToMarginEdge,
const nsStyleCoord& aCoord,
ComputeSizeFlags aFlags = eDefault);
DisplayItemArray& DisplayItemData() { return mDisplayItemData; }
--- a/layout/generic/nsIScrollableFrame.h
+++ b/layout/generic/nsIScrollableFrame.h
@@ -17,22 +17,22 @@
#include "mozilla/gfx/Point.h"
#include "nsIScrollbarMediator.h"
#include "Units.h"
#include "FrameMetrics.h"
#define NS_DEFAULT_VERTICAL_SCROLL_DISTANCE 3
#define NS_DEFAULT_HORIZONTAL_SCROLL_DISTANCE 5
+class gfxContext;
class nsBoxLayoutState;
class nsIScrollPositionListener;
class nsIFrame;
class nsPresContext;
class nsIContent;
-class nsRenderingContext;
class nsIAtom;
class nsDisplayListBuilder;
namespace mozilla {
struct ContainerLayerParameters;
namespace layers {
class Layer;
} // namespace layers
@@ -92,23 +92,23 @@ public:
*/
virtual nsMargin GetDesiredScrollbarSizes(nsBoxLayoutState* aState) = 0;
/**
* Return the sizes of all scrollbars assuming that any scrollbars that could
* be visible due to overflowing content, are. This can be called during reflow
* of the scrolled contents.
*/
virtual nsMargin GetDesiredScrollbarSizes(nsPresContext* aPresContext,
- nsRenderingContext* aRC) = 0;
+ gfxContext* aRC) = 0;
/**
* Return the width for non-disappearing scrollbars.
*/
virtual nscoord
GetNondisappearingScrollbarWidth(nsPresContext* aPresContext,
- nsRenderingContext* aRC,
+ gfxContext* aRC,
mozilla::WritingMode aWM) = 0;
/**
* GetScrolledRect is designed to encapsulate deciding which
* directions of overflow should be reachable by scrolling and which
* should not. Callers should NOT depend on it having any particular
* behavior (although nsXULScrollFrame currently does).
*
* This should only be called when the scrolled frame has been
--- a/layout/generic/nsImageFrame.cpp
+++ b/layout/generic/nsImageFrame.cpp
@@ -3,32 +3,32 @@
* 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/. */
/* rendering object for replaced elements with image data */
#include "nsImageFrame.h"
#include "gfx2DGlue.h"
+#include "gfxContext.h"
#include "gfxUtils.h"
#include "mozilla/DebugOnly.h"
#include "mozilla/EventStates.h"
#include "mozilla/gfx/2D.h"
#include "mozilla/gfx/Helpers.h"
#include "mozilla/gfx/PathHelpers.h"
#include "mozilla/MouseEvents.h"
#include "mozilla/Unused.h"
#include "nsCOMPtr.h"
#include "nsFontMetrics.h"
#include "nsIImageLoadingContent.h"
#include "nsString.h"
#include "nsPrintfCString.h"
#include "nsPresContext.h"
-#include "nsRenderingContext.h"
#include "nsIPresShell.h"
#include "nsGkAtoms.h"
#include "nsIDocument.h"
#include "nsContentUtils.h"
#include "nsCSSAnonBoxes.h"
#include "nsStyleContext.h"
#include "nsStyleConsts.h"
#include "nsStyleCoord.h"
@@ -825,17 +825,17 @@ nsImageFrame::EnsureIntrinsicSizeAndRati
}
}
}
}
}
/* virtual */
LogicalSize
-nsImageFrame::ComputeSize(nsRenderingContext *aRenderingContext,
+nsImageFrame::ComputeSize(gfxContext *aRenderingContext,
WritingMode aWM,
const LogicalSize& aCBSize,
nscoord aAvailableISize,
const LogicalSize& aMargin,
const LogicalSize& aBorder,
const LogicalSize& aPadding,
ComputeSizeFlags aFlags)
{
@@ -910,29 +910,29 @@ nsImageFrame::GetContinuationOffset() co
for (nsIFrame *f = GetPrevInFlow(); f; f = f->GetPrevInFlow()) {
offset += f->GetContentRect().height;
}
NS_ASSERTION(offset >= 0, "bogus GetContentRect");
return offset;
}
/* virtual */ nscoord
-nsImageFrame::GetMinISize(nsRenderingContext *aRenderingContext)
+nsImageFrame::GetMinISize(gfxContext *aRenderingContext)
{
// XXX The caller doesn't account for constraints of the height,
// min-height, and max-height properties.
DebugOnly<nscoord> result;
DISPLAY_MIN_WIDTH(this, result);
EnsureIntrinsicSizeAndRatio();
return mIntrinsicSize.width.GetUnit() == eStyleUnit_Coord ?
mIntrinsicSize.width.GetCoordValue() : 0;
}
/* virtual */ nscoord
-nsImageFrame::GetPrefISize(nsRenderingContext *aRenderingContext)
+nsImageFrame::GetPrefISize(gfxContext *aRenderingContext)
{
// XXX The caller doesn't account for constraints of the height,
// min-height, and max-height properties.
DebugOnly<nscoord> result;
DISPLAY_PREF_WIDTH(this, result);
EnsureIntrinsicSizeAndRatio();
// convert from normal twips to scaled twips (printing...)
return mIntrinsicSize.width.GetUnit() == eStyleUnit_Coord ?
@@ -1092,17 +1092,17 @@ nsImageFrame::ReflowCallbackCanceled()
// The number of characters that fit within the maximum width are returned in
// aMaxFit. NOTE: it is assumed that the fontmetrics have already been selected
// into the rendering context before this is called (for performance). MMP
nscoord
nsImageFrame::MeasureString(const char16_t* aString,
int32_t aLength,
nscoord aMaxWidth,
uint32_t& aMaxFit,
- nsRenderingContext& aContext,
+ gfxContext& aContext,
nsFontMetrics& aFontMetrics)
{
nscoord totalWidth = 0;
aFontMetrics.SetTextRunRTL(false);
nscoord spaceWidth = aFontMetrics.SpaceWidth();
aMaxFit = 0;
while (aLength > 0) {
@@ -1153,23 +1153,22 @@ nsImageFrame::MeasureString(const char16
}
return totalWidth;
}
// Formats the alt-text to fit within the specified rectangle. Breaks lines
// between words if a word would extend past the edge of the rectangle
void
nsImageFrame::DisplayAltText(nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
const nsString& aAltText,
const nsRect& aRect)
{
// Set font and color
- aRenderingContext.ThebesContext()->
- SetColor(Color::FromABGR(StyleColor()->mColor));
+ aRenderingContext.SetColor(Color::FromABGR(StyleColor()->mColor));
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
@@ -1310,17 +1309,17 @@ public:
virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder,
bool* aSnap) override
{
*aSnap = false;
return mFrame->GetVisualOverflowRectRelativeToSelf() + ToReferenceFrame();
}
virtual void Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) override
+ gfxContext* aCtx) override
{
// Always sync decode, because these icons are UI, and since they're not
// discardable we'll pay the price of sync decoding at most once.
uint32_t flags = imgIContainer::FLAG_SYNC_DECODE;
nsImageFrame* f = static_cast<nsImageFrame*>(mFrame);
DrawResult result =
f->DisplayAltFeedback(*aCtx,
@@ -1330,17 +1329,17 @@ public:
nsDisplayItemGenericImageGeometry::UpdateDrawResult(this, result);
}
NS_DISPLAY_DECL_NAME("AltFeedback", TYPE_ALT_FEEDBACK)
};
DrawResult
-nsImageFrame::DisplayAltFeedback(nsRenderingContext& aRenderingContext,
+nsImageFrame::DisplayAltFeedback(gfxContext& aRenderingContext,
const nsRect& aDirtyRect,
nsPoint aPt,
uint32_t aFlags)
{
// We should definitely have a gIconLoad here.
MOZ_ASSERT(gIconLoad, "How did we succeed in Init then?");
// Whether we draw the broken or loading icon.
@@ -1383,22 +1382,21 @@ nsImageFrame::DisplayAltFeedback(nsRende
// and a six pixel padding on each edge
inner.Deflate(nsPresContext::CSSPixelsToAppUnits(ICON_PADDING+ALT_BORDER_WIDTH),
nsPresContext::CSSPixelsToAppUnits(ICON_PADDING+ALT_BORDER_WIDTH));
if (inner.IsEmpty()) {
return DrawResult::SUCCESS;
}
DrawTarget* drawTarget = aRenderingContext.GetDrawTarget();
- gfxContext* gfx = aRenderingContext.ThebesContext();
// Clip so we don't render outside the inner rect
- gfx->Save();
- gfx->Clip(NSRectToSnappedRect(inner, PresContext()->AppUnitsPerDevPixel(),
- *drawTarget));
+ aRenderingContext.Save();
+ aRenderingContext.Clip(
+ NSRectToSnappedRect(inner, PresContext()->AppUnitsPerDevPixel(), *drawTarget));
DrawResult result = DrawResult::NOT_READY;
// Check if we should display image placeholders
if (!gIconLoad->mPrefShowPlaceholders ||
(isLoading && !gIconLoad->mPrefShowLoadingPlaceholder)) {
result = DrawResult::SUCCESS;
} else {
@@ -1425,17 +1423,17 @@ nsImageFrame::DisplayAltFeedback(nsRende
if (request)
request->GetImageStatus(&imageStatus);
if (imageStatus & imgIRequest::STATUS_LOAD_COMPLETE) {
nsCOMPtr<imgIContainer> imgCon;
request->GetImage(getter_AddRefs(imgCon));
MOZ_ASSERT(imgCon, "Load complete, but no image container?");
nsRect dest(flushRight ? inner.XMost() - size : inner.x,
inner.y, size, size);
- result = nsLayoutUtils::DrawSingleImage(*gfx, PresContext(), imgCon,
+ result = nsLayoutUtils::DrawSingleImage(aRenderingContext, PresContext(), imgCon,
nsLayoutUtils::GetSamplingFilterForFrame(this), dest, aDirtyRect,
/* no SVGImageContext */ Nothing(), aFlags);
}
// If we could not draw the icon, just draw some graffiti in the mean time.
if (result == DrawResult::NOT_READY) {
ColorPattern color(ToDeviceColor(Color(1.f, 0.f, 0.f, 1.f)));
@@ -1481,17 +1479,17 @@ nsImageFrame::DisplayAltFeedback(nsRende
nsXPIDLString altText;
nsCSSFrameConstructor::GetAlternateTextFor(content,
content->NodeInfo()->NameAtom(),
altText);
DisplayAltText(PresContext(), aRenderingContext, altText, inner);
}
}
- aRenderingContext.ThebesContext()->Restore();
+ aRenderingContext.Restore();
return result;
}
#ifdef DEBUG
static void PaintDebugImageMap(nsIFrame* aFrame, DrawTarget* aDrawTarget,
const nsRect& aDirtyRect, nsPoint aPt)
{
@@ -1505,17 +1503,17 @@ static void PaintDebugImageMap(nsIFrame*
aDrawTarget->GetTransform().PreTranslate(ToPoint(devPixelOffset)));
f->GetImageMap()->Draw(aFrame, *aDrawTarget,
ColorPattern(ToDeviceColor(Color(0.f, 0.f, 0.f, 1.f))));
}
#endif
void
nsDisplayImage::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx)
+ gfxContext* aCtx)
{
uint32_t flags = imgIContainer::FLAG_NONE;
if (aBuilder->ShouldSyncDecodeImages()) {
flags |= imgIContainer::FLAG_SYNC_DECODE;
}
if (aBuilder->IsPaintingToWindow()) {
flags |= imgIContainer::FLAG_HIGH_QUALITY_SCALING;
}
@@ -1678,17 +1676,17 @@ nsDisplayImage::BuildLayer(nsDisplayList
return nullptr;
}
layer->SetContainer(container);
ConfigureLayer(layer, aParameters);
return layer.forget();
}
DrawResult
-nsImageFrame::PaintImage(nsRenderingContext& aRenderingContext, nsPoint aPt,
+nsImageFrame::PaintImage(gfxContext& aRenderingContext, nsPoint aPt,
const nsRect& aDirtyRect, imgIContainer* aImage,
uint32_t aFlags)
{
DrawTarget* drawTarget = aRenderingContext.GetDrawTarget();
// Render the image into our content area (the area inside
// the borders and padding)
NS_ASSERTION(GetInnerArea().width == mComputedSize.width, "bad width");
@@ -1711,17 +1709,17 @@ nsImageFrame::PaintImage(nsRenderingCont
if (mForceSyncDecoding) {
flags |= imgIContainer::FLAG_SYNC_DECODE;
}
Maybe<SVGImageContext> svgContext;
SVGImageContext::MaybeStoreContextPaint(svgContext, this, aImage);
DrawResult result =
- nsLayoutUtils::DrawSingleImage(*aRenderingContext.ThebesContext(),
+ nsLayoutUtils::DrawSingleImage(aRenderingContext,
PresContext(), aImage,
nsLayoutUtils::GetSamplingFilterForFrame(this), dest, aDirtyRect,
svgContext, flags, &anchorPoint);
nsImageMap* map = GetImageMap();
if (map) {
gfxPoint devPixelOffset =
nsLayoutUtils::PointToGfxPoint(dest.TopLeft(),
@@ -2450,16 +2448,16 @@ IsInAutoWidthTableCellForQuirk(nsIFrame
nsFrame *grandAncestor = static_cast<nsFrame*>(ancestor->GetParent());
return grandAncestor &&
grandAncestor->StylePosition()->mWidth.GetUnit() == eStyleUnit_Auto;
}
return false;
}
/* virtual */ void
-nsImageFrame::AddInlineMinISize(nsRenderingContext* aRenderingContext,
+nsImageFrame::AddInlineMinISize(gfxContext* aRenderingContext,
nsIFrame::InlineMinISizeData* aData)
{
nscoord isize = nsLayoutUtils::IntrinsicForContainer(aRenderingContext,
this, nsLayoutUtils::MIN_ISIZE);
bool canBreak = !IsInAutoWidthTableCellForQuirk(this);
aData->DefaultAddInlineMinISize(this, isize, canBreak);
}
--- a/layout/generic/nsImageFrame.h
+++ b/layout/generic/nsImageFrame.h
@@ -76,18 +76,18 @@ public:
virtual void DidSetStyleContext(nsStyleContext* aOldStyleContext) override;
virtual void Init(nsIContent* aContent,
nsContainerFrame* aParent,
nsIFrame* aPrevInFlow) override;
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) override;
- virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override;
- virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override;
+ virtual nscoord GetMinISize(gfxContext *aRenderingContext) override;
+ virtual nscoord GetPrefISize(gfxContext *aRenderingContext) override;
virtual mozilla::IntrinsicSize GetIntrinsicSize() override;
virtual nsSize GetIntrinsicRatio() override;
virtual void Reflow(nsPresContext* aPresContext,
ReflowOutput& aDesiredSize,
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus) override;
virtual nsresult GetContentForEvent(mozilla::WidgetEvent* aEvent,
@@ -142,17 +142,17 @@ public:
/**
* Function to test whether aContent, which has aStyleContext as its style,
* should get an image frame. Note that this method is only used by the
* frame constructor; it's only here because it uses gIconLoad for now.
*/
static bool ShouldCreateImageFrameFor(mozilla::dom::Element* aElement,
nsStyleContext* aStyleContext);
- DrawResult DisplayAltFeedback(nsRenderingContext& aRenderingContext,
+ DrawResult DisplayAltFeedback(gfxContext& aRenderingContext,
const nsRect& aDirtyRect,
nsPoint aPt,
uint32_t aFlags);
nsRect GetInnerArea() const;
/**
* Return a map element associated with this image.
@@ -162,17 +162,17 @@ public:
/**
* Return true if the image has associated image map.
*/
bool HasImageMap() const { return mImageMap || GetMapElement(); }
nsImageMap* GetImageMap();
nsImageMap* GetExistingImageMap() const { return mImageMap; }
- virtual void AddInlineMinISize(nsRenderingContext *aRenderingContext,
+ virtual void AddInlineMinISize(gfxContext *aRenderingContext,
InlineMinISizeData *aData) override;
void DisconnectMap();
// nsIReflowCallback
virtual bool ReflowFinished() override;
virtual void ReflowCallbackCanceled() override;
@@ -183,17 +183,17 @@ private:
protected:
nsImageFrame(nsStyleContext* aContext, ClassID aID);
virtual ~nsImageFrame();
void EnsureIntrinsicSizeAndRatio();
virtual mozilla::LogicalSize
- ComputeSize(nsRenderingContext *aRenderingContext,
+ ComputeSize(gfxContext *aRenderingContext,
mozilla::WritingMode aWritingMode,
const mozilla::LogicalSize& aCBSize,
nscoord aAvailableISize,
const mozilla::LogicalSize& aMargin,
const mozilla::LogicalSize& aBorder,
const mozilla::LogicalSize& aPadding,
ComputeSizeFlags aFlags) override;
@@ -212,25 +212,25 @@ protected:
* @param out aMaxFit length of the string that fits within aMaxWidth
* in PRUnichars
* @return width of the string that fits within aMaxWidth
*/
nscoord MeasureString(const char16_t* aString,
int32_t aLength,
nscoord aMaxWidth,
uint32_t& aMaxFit,
- nsRenderingContext& aContext,
+ gfxContext& aContext,
nsFontMetrics& aFontMetrics);
void DisplayAltText(nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
const nsString& aAltText,
const nsRect& aRect);
- DrawResult PaintImage(nsRenderingContext& aRenderingContext, nsPoint aPt,
+ DrawResult PaintImage(gfxContext& aRenderingContext, nsPoint aPt,
const nsRect& aDirtyRect, imgIContainer* aImage,
uint32_t aFlags);
/**
* If we're ready to decode - that is, if our current request's image is
* available and our decoding heuristics are satisfied - then trigger a decode
* for our image at the size we predict it will be drawn next time it's
* painted.
@@ -422,17 +422,17 @@ public:
MOZ_COUNT_DTOR(nsDisplayImage);
}
virtual nsDisplayItemGeometry* AllocateGeometry(nsDisplayListBuilder* aBuilder) override;
virtual void ComputeInvalidationRegion(nsDisplayListBuilder* aBuilder,
const nsDisplayItemGeometry* aGeometry,
nsRegion* aInvalidRegion) override;
virtual void Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) override;
+ gfxContext* aCtx) override;
virtual already_AddRefed<imgIContainer> GetImage() override;
/**
* @return The dest rect we'll use when drawing this image, in app units.
* Not necessarily contained in this item's bounds.
*/
virtual nsRect GetDestRect() override;
--- a/layout/generic/nsInlineFrame.cpp
+++ b/layout/generic/nsInlineFrame.cpp
@@ -1,23 +1,23 @@
/* -*- 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/. */
/* rendering object for CSS display:inline objects */
+#include "gfxContext.h"
#include "nsInlineFrame.h"
#include "nsLineLayout.h"
#include "nsBlockFrame.h"
#include "nsPlaceholderFrame.h"
#include "nsGkAtoms.h"
#include "nsStyleContext.h"
#include "nsPresContext.h"
-#include "nsRenderingContext.h"
#include "nsCSSAnonBoxes.h"
#include "mozilla/RestyleManager.h"
#include "mozilla/RestyleManagerInlines.h"
#include "nsDisplayList.h"
#include "mozilla/Likely.h"
#include "SVGTextFrame.h"
#include "nsStyleChangeList.h"
#include "mozilla/StyleSetHandle.h"
@@ -251,33 +251,33 @@ nsInlineFrame::BuildDisplayList(nsDispla
DisplaySelectionOverlay(aBuilder, aLists.Content());
}
}
//////////////////////////////////////////////////////////////////////
// Reflow methods
/* virtual */ void
-nsInlineFrame::AddInlineMinISize(nsRenderingContext *aRenderingContext,
+nsInlineFrame::AddInlineMinISize(gfxContext *aRenderingContext,
nsIFrame::InlineMinISizeData *aData)
{
DoInlineIntrinsicISize(aRenderingContext, aData, nsLayoutUtils::MIN_ISIZE);
}
/* virtual */ void
-nsInlineFrame::AddInlinePrefISize(nsRenderingContext *aRenderingContext,
+nsInlineFrame::AddInlinePrefISize(gfxContext *aRenderingContext,
nsIFrame::InlinePrefISizeData *aData)
{
DoInlineIntrinsicISize(aRenderingContext, aData, nsLayoutUtils::PREF_ISIZE);
aData->mLineIsEmpty = false;
}
/* virtual */
LogicalSize
-nsInlineFrame::ComputeSize(nsRenderingContext *aRenderingContext,
+nsInlineFrame::ComputeSize(gfxContext *aRenderingContext,
WritingMode aWM,
const LogicalSize& aCBSize,
nscoord aAvailableISize,
const LogicalSize& aMargin,
const LogicalSize& aBorder,
const LogicalSize& aPadding,
ComputeSizeFlags aFlags)
{
--- a/layout/generic/nsInlineFrame.h
+++ b/layout/generic/nsInlineFrame.h
@@ -58,22 +58,22 @@ public:
virtual FrameSearchResult PeekOffsetCharacter(bool aForward, int32_t* aOffset,
bool aRespectClusters = true) override;
virtual void DestroyFrom(nsIFrame* aDestructRoot) override;
virtual nsresult StealFrame(nsIFrame* aChild) override;
// nsIHTMLReflow overrides
- virtual void AddInlineMinISize(nsRenderingContext *aRenderingContext,
+ virtual void AddInlineMinISize(gfxContext *aRenderingContext,
InlineMinISizeData *aData) override;
- virtual void AddInlinePrefISize(nsRenderingContext *aRenderingContext,
+ virtual void AddInlinePrefISize(gfxContext *aRenderingContext,
InlinePrefISizeData *aData) override;
virtual mozilla::LogicalSize
- ComputeSize(nsRenderingContext *aRenderingContext,
+ ComputeSize(gfxContext *aRenderingContext,
mozilla::WritingMode aWritingMode,
const mozilla::LogicalSize& aCBSize,
nscoord aAvailableISize,
const mozilla::LogicalSize& aMargin,
const mozilla::LogicalSize& aBorder,
const mozilla::LogicalSize& aPadding,
ComputeSizeFlags aFlags) override;
virtual nsRect ComputeTightBounds(DrawTarget* aDrawTarget) const override;
--- a/layout/generic/nsLeafFrame.cpp
+++ b/layout/generic/nsLeafFrame.cpp
@@ -10,36 +10,36 @@
using namespace mozilla;
nsLeafFrame::~nsLeafFrame()
{
}
/* virtual */ nscoord
-nsLeafFrame::GetMinISize(nsRenderingContext *aRenderingContext)
+nsLeafFrame::GetMinISize(gfxContext *aRenderingContext)
{
nscoord result;
DISPLAY_MIN_WIDTH(this, result);
result = GetIntrinsicISize();
return result;
}
/* virtual */ nscoord
-nsLeafFrame::GetPrefISize(nsRenderingContext *aRenderingContext)
+nsLeafFrame::GetPrefISize(gfxContext *aRenderingContext)
{
nscoord result;
DISPLAY_PREF_WIDTH(this, result);
result = GetIntrinsicISize();
return result;
}
/* virtual */
LogicalSize
-nsLeafFrame::ComputeAutoSize(nsRenderingContext* aRenderingContext,
+nsLeafFrame::ComputeAutoSize(gfxContext* aRenderingContext,
WritingMode aWM,
const LogicalSize& aCBSize,
nscoord aAvailableISize,
const LogicalSize& aMargin,
const LogicalSize& aBorder,
const LogicalSize& aPadding,
ComputeSizeFlags aFlags)
{
--- a/layout/generic/nsLeafFrame.h
+++ b/layout/generic/nsLeafFrame.h
@@ -29,24 +29,24 @@ public:
DO_GLOBAL_REFLOW_COUNT_DSP("nsLeafFrame");
DisplayBorderBackgroundOutline(aBuilder, aLists);
}
/**
* Both GetMinISize and GetPrefISize will return whatever GetIntrinsicISize
* returns.
*/
- virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override;
- virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override;
+ virtual nscoord GetMinISize(gfxContext *aRenderingContext) override;
+ virtual nscoord GetPrefISize(gfxContext *aRenderingContext) override;
/**
* Our auto size is just intrinsic width and intrinsic height.
*/
virtual mozilla::LogicalSize
- ComputeAutoSize(nsRenderingContext* aRenderingContext,
+ ComputeAutoSize(gfxContext* aRenderingContext,
mozilla::WritingMode aWM,
const mozilla::LogicalSize& aCBSize,
nscoord aAvailableISize,
const mozilla::LogicalSize& aMargin,
const mozilla::LogicalSize& aBorder,
const mozilla::LogicalSize& aPadding,
ComputeSizeFlags aFlags) override;
--- a/layout/generic/nsPageFrame.cpp
+++ b/layout/generic/nsPageFrame.cpp
@@ -1,21 +1,21 @@
/* -*- 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 "nsPageFrame.h"
#include "mozilla/gfx/2D.h"
+#include "gfxContext.h"
#include "nsDeviceContext.h"
#include "nsFontMetrics.h"
#include "nsLayoutUtils.h"
#include "nsPresContext.h"
-#include "nsRenderingContext.h"
#include "nsGkAtoms.h"
#include "nsIPresShell.h"
#include "nsPageContentFrame.h"
#include "nsDisplayList.h"
#include "nsLayoutUtils.h" // for function BinarySearchForPosition
#include "nsSimplePageSequenceFrame.h" // for nsSharedPageData
#include "nsTextFormatter.h" // for page number localization formatting
#include "nsBidiUtils.h"
@@ -226,17 +226,17 @@ nsPageFrame::ProcessSpecialCodes(const n
char16_t * uStr = nsTextFormatter::smprintf(mPD->mPageNumFormat.get(), mTotNumPages);
aNewStr.ReplaceSubstring(kPageTotal, nsDependentString(uStr));
free(uStr);
}
}
//------------------------------------------------------------------------------
-nscoord nsPageFrame::GetXPosition(nsRenderingContext& aRenderingContext,
+nscoord nsPageFrame::GetXPosition(gfxContext& aRenderingContext,
nsFontMetrics& aFontMetrics,
const nsRect& aRect,
int32_t aJust,
const nsString& aStr)
{
nscoord width = nsLayoutUtils::AppUnitWidthOfStringBidi(aStr, this,
aFontMetrics,
aRenderingContext);
@@ -263,17 +263,17 @@ nscoord nsPageFrame::GetXPosition(nsRend
// @param aHeaderFooter - indicates whether it is a header or footer
// @param aStrLeft - string for the left header or footer; can be empty
// @param aStrCenter - string for the center header or footer; can be empty
// @param aStrRight - string for the right header or footer; can be empty
// @param aRect - the rect of the page
// @param aAscent - the ascent of the font
// @param aHeight - the height of the font
void
-nsPageFrame::DrawHeaderFooter(nsRenderingContext& aRenderingContext,
+nsPageFrame::DrawHeaderFooter(gfxContext& aRenderingContext,
nsFontMetrics& aFontMetrics,
nsHeaderFooterEnum aHeaderFooter,
const nsString& aStrLeft,
const nsString& aStrCenter,
const nsString& aStrRight,
const nsRect& aRect,
nscoord aAscent,
nscoord aHeight)
@@ -308,30 +308,29 @@ nsPageFrame::DrawHeaderFooter(nsRenderin
// @param aHeaderFooter - indicates whether it is a header or footer
// @param aJust - indicates where the string is located within the header/footer
// @param aStr - the string to be drawn
// @param aRect - the rect of the page
// @param aHeight - the height of the font
// @param aAscent - the ascent of the font
// @param aWidth - available width for the string
void
-nsPageFrame::DrawHeaderFooter(nsRenderingContext& aRenderingContext,
+nsPageFrame::DrawHeaderFooter(gfxContext& aRenderingContext,
nsFontMetrics& aFontMetrics,
nsHeaderFooterEnum aHeaderFooter,
int32_t aJust,
const nsString& aStr,
const nsRect& aRect,
nscoord aAscent,
nscoord aHeight,
nscoord aWidth)
{
nscoord contentWidth = aWidth - (mPD->mEdgePaperMargin.left + mPD->mEdgePaperMargin.right);
- gfxContext* gfx = aRenderingContext.ThebesContext();
DrawTarget* drawTarget = aRenderingContext.GetDrawTarget();
if ((aHeaderFooter == eHeader && aHeight < mPageContentMargin.top) ||
(aHeaderFooter == eFooter && aHeight < mPageContentMargin.bottom)) {
nsAutoString str;
ProcessSpecialCodes(aStr, str);
int32_t indx;
@@ -376,26 +375,26 @@ nsPageFrame::DrawHeaderFooter(nsRenderin
nscoord y;
if (aHeaderFooter == eHeader) {
y = aRect.y + mPD->mEdgePaperMargin.top;
} else {
y = aRect.YMost() - aHeight - mPD->mEdgePaperMargin.bottom;
}
// set up new clip and draw the text
- gfx->Save();
- gfx->Clip(NSRectToSnappedRect(aRect, PresContext()->AppUnitsPerDevPixel(),
- *drawTarget));
- gfx->SetColor(Color(0.f, 0.f, 0.f));
+ aRenderingContext.Save();
+ aRenderingContext.Clip(
+ NSRectToSnappedRect(aRect, PresContext()->AppUnitsPerDevPixel(), *drawTarget));
+ aRenderingContext.SetColor(Color(0.f, 0.f, 0.f));
nsLayoutUtils::DrawString(this, aFontMetrics, &aRenderingContext,
str.get(), str.Length(),
nsPoint(x, y + aAscent),
nullptr,
DrawStringFlags::eForceHorizontal);
- gfx->Restore();
+ aRenderingContext.Restore();
}
}
/**
* Remove all leaf display items that are not for descendants of
* aBuilder->GetReferenceFrame() from aList.
* @param aPage the page we're constructing the display list for
* @param aExtraPage the page we constructed aList for
@@ -483,17 +482,17 @@ public:
}
#ifdef NS_BUILD_REFCNT_LOGGING
virtual ~nsDisplayHeaderFooter() {
MOZ_COUNT_DTOR(nsDisplayHeaderFooter);
}
#endif
virtual void Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) override {
+ gfxContext* aCtx) override {
#ifdef DEBUG
nsPageFrame* pageFrame = do_QueryFrame(mFrame);
MOZ_ASSERT(pageFrame, "We should have an nsPageFrame");
#endif
static_cast<nsPageFrame*>(mFrame)->
PaintHeaderFooter(*aCtx, ToReferenceFrame(), mDisableSubpixelAA);
}
NS_DISPLAY_DECL_NAME("HeaderFooter", nsDisplayItem::TYPE_HEADER_FOOTER)
@@ -602,30 +601,30 @@ void
nsPageFrame::SetPageNumInfo(int32_t aPageNumber, int32_t aTotalPages)
{
mPageNum = aPageNumber;
mTotNumPages = aTotalPages;
}
void
-nsPageFrame::PaintHeaderFooter(nsRenderingContext& aRenderingContext,
+nsPageFrame::PaintHeaderFooter(gfxContext& aRenderingContext,
nsPoint aPt, bool aDisableSubpixelAA)
{
nsPresContext* pc = PresContext();
if (!mPD->mPrintSettings) {
if (pc->Type() == nsPresContext::eContext_PrintPreview || pc->IsDynamic())
mPD->mPrintSettings = pc->GetPrintSettings();
if (!mPD->mPrintSettings)
return;
}
nsRect rect(aPt, mRect.Size());
- aRenderingContext.ThebesContext()->SetColor(Color(0.f, 0.f, 0.f));
+ aRenderingContext.SetColor(Color(0.f, 0.f, 0.f));
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();
--- a/layout/generic/nsPageFrame.h
+++ b/layout/generic/nsPageFrame.h
@@ -43,45 +43,45 @@ public:
virtual void SetPageNumInfo(int32_t aPageNumber, int32_t aTotalPages);
virtual void SetSharedPageData(nsSharedPageData* aPD);
// We must allow Print Preview UI to have a background, no matter what the
// user's settings
virtual bool HonorPrintBackgroundSettings() override { return false; }
- void PaintHeaderFooter(nsRenderingContext& aRenderingContext,
+ void PaintHeaderFooter(gfxContext& aRenderingContext,
nsPoint aPt, bool aSubpixelAA);
protected:
explicit nsPageFrame(nsStyleContext* aContext);
virtual ~nsPageFrame();
typedef enum {
eHeader,
eFooter
} nsHeaderFooterEnum;
- nscoord GetXPosition(nsRenderingContext& aRenderingContext,
+ nscoord GetXPosition(gfxContext& aRenderingContext,
nsFontMetrics& aFontMetrics,
const nsRect& aRect,
int32_t aJust,
const nsString& aStr);
- void DrawHeaderFooter(nsRenderingContext& aRenderingContext,
+ void DrawHeaderFooter(gfxContext& aRenderingContext,
nsFontMetrics& aFontMetrics,
nsHeaderFooterEnum aHeaderFooter,
int32_t aJust,
const nsString& sStr,
const nsRect& aRect,
nscoord aHeight,
nscoord aAscent,
nscoord aWidth);
- void DrawHeaderFooter(nsRenderingContext& aRenderingContext,
+ void DrawHeaderFooter(gfxContext& aRenderingContext,
nsFontMetrics& aFontMetrics,
nsHeaderFooterEnum aHeaderFooter,
const nsString& aStrLeft,
const nsString& aStrRight,
const nsString& aStrCenter,
const nsRect& aRect,
nscoord aAscent,
nscoord aHeight);
--- a/layout/generic/nsPlaceholderFrame.cpp
+++ b/layout/generic/nsPlaceholderFrame.cpp
@@ -5,23 +5,23 @@
/*
* rendering object for the point that anchors out-of-flow rendering
* objects such as floats and absolutely positioned elements
*/
#include "nsPlaceholderFrame.h"
+#include "gfxContext.h"
#include "gfxUtils.h"
#include "mozilla/gfx/2D.h"
#include "nsDisplayList.h"
#include "nsFrameManager.h"
#include "nsLayoutUtils.h"
#include "nsPresContext.h"
-#include "nsRenderingContext.h"
#include "nsIFrameInlines.h"
#include "nsIContentInlines.h"
using namespace mozilla;
using namespace mozilla::gfx;
nsIFrame*
NS_NewPlaceholderFrame(nsIPresShell* aPresShell, nsStyleContext* aContext,
@@ -58,17 +58,17 @@ nsPlaceholderFrame::GetXULPrefSize(nsBox
nsPlaceholderFrame::GetXULMaxSize(nsBoxLayoutState& aBoxLayoutState)
{
nsSize size(NS_INTRINSICSIZE, NS_INTRINSICSIZE);
DISPLAY_MAX_SIZE(this, size);
return size;
}
/* virtual */ void
-nsPlaceholderFrame::AddInlineMinISize(nsRenderingContext* aRenderingContext,
+nsPlaceholderFrame::AddInlineMinISize(gfxContext* aRenderingContext,
nsIFrame::InlineMinISizeData* aData)
{
// Override AddInlineMinWith so that *nothing* happens. In
// particular, we don't want to zero out |aData->mTrailingWhitespace|,
// since nsLineLayout skips placeholders when trimming trailing
// whitespace, and we don't want to set aData->mSkipWhitespace to
// false.
@@ -79,17 +79,17 @@ nsPlaceholderFrame::AddInlineMinISize(ns
mOutOfFlowFrame,
nsLayoutUtils::MIN_ISIZE);
aData->mFloats.AppendElement(
InlineIntrinsicISizeData::FloatInfo(mOutOfFlowFrame, floatWidth));
}
}
/* virtual */ void
-nsPlaceholderFrame::AddInlinePrefISize(nsRenderingContext* aRenderingContext,
+nsPlaceholderFrame::AddInlinePrefISize(gfxContext* aRenderingContext,
nsIFrame::InlinePrefISizeData* aData)
{
// Override AddInlinePrefWith so that *nothing* happens. In
// particular, we don't want to zero out |aData->mTrailingWhitespace|,
// since nsLineLayout skips placeholders when trimming trailing
// whitespace, and we don't want to set aData->mSkipWhitespace to
// false.
--- a/layout/generic/nsPlaceholderFrame.h
+++ b/layout/generic/nsPlaceholderFrame.h
@@ -85,19 +85,19 @@ public:
NS_ASSERTION(!aFrame || !aFrame->GetPrevContinuation(),
"OOF must be first continuation");
mOutOfFlowFrame = aFrame;
}
// nsIFrame overrides
// We need to override GetXULMinSize and GetXULPrefSize because XUL uses
// placeholders not within lines.
- virtual void AddInlineMinISize(nsRenderingContext* aRenderingContext,
+ virtual void AddInlineMinISize(gfxContext* aRenderingContext,
InlineMinISizeData* aData) override;
- virtual void AddInlinePrefISize(nsRenderingContext* aRenderingContext,
+ virtual void AddInlinePrefISize(gfxContext* aRenderingContext,
InlinePrefISizeData* aData) override;
virtual nsSize GetXULMinSize(nsBoxLayoutState& aBoxLayoutState) override;
virtual nsSize GetXULPrefSize(nsBoxLayoutState& aBoxLayoutState) override;
virtual nsSize GetXULMaxSize(nsBoxLayoutState& aBoxLayoutState) override;
virtual void Reflow(nsPresContext* aPresContext,
ReflowOutput& aDesiredSize,
const ReflowInput& aReflowInput,
--- a/layout/generic/nsPluginFrame.cpp
+++ b/layout/generic/nsPluginFrame.cpp
@@ -4,16 +4,17 @@
* 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/. */
/* rendering objects for replaced elements implemented by a plugin */
#include "nsPluginFrame.h"
#include "gfx2DGlue.h"
+#include "gfxContext.h"
#include "gfxMatrix.h"
#include "mozilla/gfx/2D.h"
#include "mozilla/BasicEvents.h"
#include "mozilla/MouseEvents.h"
#ifdef XP_WIN
// This is needed for DoublePassRenderingEvent.
#include "mozilla/plugins/PluginMessageUtils.h"
#endif
@@ -25,17 +26,16 @@
#include "nsWidgetsCID.h"
#include "nsView.h"
#include "nsViewManager.h"
#include "nsString.h"
#include "nsGkAtoms.h"
#include "nsIPluginInstanceOwner.h"
#include "nsNPAPIPluginInstance.h"
#include "nsIDOMElement.h"
-#include "nsRenderingContext.h"
#include "npapi.h"
#include "nsIObjectLoadingContent.h"
#include "nsContentUtils.h"
#include "nsDisplayList.h"
#include "nsFocusManager.h"
#include "nsLayoutUtils.h"
#include "nsFrameManager.h"
#include "nsIObserverService.h"
@@ -369,17 +369,17 @@ nsPluginFrame::PrepForDrawing(nsIWidget
return NS_OK;
}
#define EMBED_DEF_WIDTH 240
#define EMBED_DEF_HEIGHT 200
/* virtual */ nscoord
-nsPluginFrame::GetMinISize(nsRenderingContext *aRenderingContext)
+nsPluginFrame::GetMinISize(gfxContext *aRenderingContext)
{
nscoord result = 0;
if (!IsHidden(false)) {
if (mContent->IsAnyOfHTMLElements(nsGkAtoms::applet,
nsGkAtoms::embed)) {
bool vertical = GetWritingMode().IsVertical();
result = nsPresContext::CSSPixelsToAppUnits(
@@ -387,17 +387,17 @@ nsPluginFrame::GetMinISize(nsRenderingCo
}
}
DISPLAY_MIN_WIDTH(this, result);
return result;
}
/* virtual */ nscoord
-nsPluginFrame::GetPrefISize(nsRenderingContext *aRenderingContext)
+nsPluginFrame::GetPrefISize(gfxContext *aRenderingContext)
{
return nsPluginFrame::GetMinISize(aRenderingContext);
}
void
nsPluginFrame::GetWidgetConfiguration(nsTArray<nsIWidget::Configuration>* aConfigurations)
{
if (!mWidget) {
@@ -866,28 +866,26 @@ nsPluginFrame::DidReflow(nsPresContext*
nsView* view = GetView();
nsViewManager* vm = view->GetViewManager();
if (vm)
vm->SetViewVisibility(view, IsHidden() ? nsViewVisibility_kHide : nsViewVisibility_kShow);
}
}
/* static */ void
-nsPluginFrame::PaintPrintPlugin(nsIFrame* aFrame, nsRenderingContext* aCtx,
+nsPluginFrame::PaintPrintPlugin(nsIFrame* aFrame, gfxContext* aCtx,
const nsRect& aDirtyRect, nsPoint aPt)
{
- gfxContext* ctx = aCtx->ThebesContext();
-
// Translate the context:
nsPoint pt = aPt + aFrame->GetContentRectRelativeToSelf().TopLeft();
gfxPoint devPixelPt =
nsLayoutUtils::PointToGfxPoint(pt, aFrame->PresContext()->AppUnitsPerDevPixel());
- gfxContextMatrixAutoSaveRestore autoSR(ctx);
- ctx->SetMatrix(ctx->CurrentMatrix().Translate(devPixelPt));
+ gfxContextMatrixAutoSaveRestore autoSR(aCtx);
+ aCtx->SetMatrix(aCtx->CurrentMatrix().Translate(devPixelPt));
// FIXME - Bug 385435: Doesn't aDirtyRect need translating too?
static_cast<nsPluginFrame*>(aFrame)->PrintPlugin(*aCtx, aDirtyRect);
}
/**
* nsDisplayPluginReadback creates an active ReadbackLayer. The ReadbackLayer
@@ -995,17 +993,17 @@ nsRect
nsDisplayPlugin::GetBounds(nsDisplayListBuilder* aBuilder, bool* aSnap)
{
*aSnap = true;
return GetDisplayItemBounds(aBuilder, this, mFrame);
}
void
nsDisplayPlugin::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx)
+ gfxContext* aCtx)
{
nsPluginFrame* f = static_cast<nsPluginFrame*>(mFrame);
bool snap;
f->PaintPlugin(aBuilder, *aCtx, mVisibleRect, GetBounds(aBuilder, &snap));
}
static nsRect
GetClippedBoundsIncludingAllScrollClips(nsDisplayItem* aItem,
@@ -1267,17 +1265,17 @@ nsPluginFrame::BuildDisplayList(nsDispla
#endif
aLists.Content()->AppendNewToTop(new (aBuilder)
nsDisplayPlugin(aBuilder, this));
}
}
void
-nsPluginFrame::PrintPlugin(nsRenderingContext& aRenderingContext,
+nsPluginFrame::PrintPlugin(gfxContext& aRenderingContext,
const nsRect& aDirtyRect)
{
nsCOMPtr<nsIObjectLoadingContent> obj(do_QueryInterface(mContent));
if (!obj)
return;
nsIFrame* frame = nullptr;
obj->GetPrintFrame(&frame);
@@ -1338,43 +1336,41 @@ nsPluginFrame::PrintPlugin(nsRenderingCo
/* we'll already be translated into the right spot by gfxWindowsNativeDrawing */
nsSize contentSize = GetContentRectRelativeToSelf().Size();
window.x = 0;
window.y = 0;
window.width = presContext->AppUnitsToDevPixels(contentSize.width);
window.height = presContext->AppUnitsToDevPixels(contentSize.height);
- gfxContext *ctx = aRenderingContext.ThebesContext();
-
- ctx->Save();
+ aRenderingContext.Save();
/* Make sure plugins don't do any damage outside of where they're supposed to */
- ctx->NewPath();
+ aRenderingContext.NewPath();
gfxRect r(window.x, window.y, window.width, window.height);
- ctx->Rectangle(r);
- ctx->Clip();
+ aRenderingContext.Rectangle(r);
+ aRenderingContext.Clip();
- gfxWindowsNativeDrawing nativeDraw(ctx, r);
+ gfxWindowsNativeDrawing nativeDraw(&aRenderingContext, r);
do {
HDC dc = nativeDraw.BeginNativeDrawing();
if (!dc)
return;
// XXX don't we need to call nativeDraw.TransformToNativeRect here?
npprint.print.embedPrint.platformPrint = dc;
npprint.print.embedPrint.window = window;
// send off print info to plugin
pi->Print(&npprint);
nativeDraw.EndNativeDrawing();
} while (nativeDraw.ShouldRenderAgain());
nativeDraw.PaintToContext();
- ctx->Restore();
+ aRenderingContext.Restore();
#endif
// XXX Nav 4.x always sent a SetWindow call after print. Should we do the same?
// XXX Calling DidReflow here makes no sense!!!
nsDidReflowStatus status = nsDidReflowStatus::FINISHED; // should we use a special status?
frame->DidReflow(presContext,
nullptr, status); // DidReflow will take care of it
}
@@ -1598,29 +1594,27 @@ nsPluginFrame::BuildLayer(nsDisplayListB
Matrix transform = Matrix::Translation(p.x, p.y);
layer->SetBaseTransform(Matrix4x4::From2D(transform));
return layer.forget();
}
void
nsPluginFrame::PaintPlugin(nsDisplayListBuilder* aBuilder,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
const nsRect& aDirtyRect, const nsRect& aPluginRect)
{
#if defined(MOZ_WIDGET_ANDROID)
if (mInstanceOwner) {
gfxRect frameGfxRect =
PresContext()->AppUnitsToGfxUnits(aPluginRect);
gfxRect dirtyGfxRect =
PresContext()->AppUnitsToGfxUnits(aDirtyRect);
- gfxContext* ctx = aRenderingContext.ThebesContext();
-
- mInstanceOwner->Paint(ctx, frameGfxRect, dirtyGfxRect);
+ mInstanceOwner->Paint(&aRenderingContext, frameGfxRect, dirtyGfxRect);
return;
}
#else
# if defined(DEBUG)
// On Desktop, we should have built a layer as we no longer support in-process
// plugins or synchronous painting. We can only get here for windowed plugins
// (which draw themselves), or via some error/unload state.
if (mInstanceOwner) {
--- a/layout/generic/nsPluginFrame.h
+++ b/layout/generic/nsPluginFrame.h
@@ -65,18 +65,18 @@ public:
NS_DECL_FRAMEARENA_HELPERS(nsPluginFrame)
NS_DECL_QUERYFRAME
friend nsIFrame* NS_NewObjectFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
virtual void Init(nsIContent* aContent,
nsContainerFrame* aParent,
nsIFrame* aPrevInFlow) override;
- virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override;
- virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override;
+ virtual nscoord GetMinISize(gfxContext *aRenderingContext) override;
+ virtual nscoord GetPrefISize(gfxContext *aRenderingContext) override;
virtual void Reflow(nsPresContext* aPresContext,
ReflowOutput& aDesiredSize,
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus) override;
virtual void DidReflow(nsPresContext* aPresContext,
const ReflowInput* aReflowInput,
nsDidReflowStatus aStatus) override;
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
@@ -247,22 +247,22 @@ protected:
/*
* If this frame is in a remote tab, return the tab offset to
* the origin of the chrome window. In non-e10s, this return 0,0.
* This api sends a sync ipc request so be careful about use.
*/
LayoutDeviceIntPoint GetRemoteTabChromeOffset();
static void PaintPrintPlugin(nsIFrame* aFrame,
- nsRenderingContext* aRenderingContext,
+ gfxContext* aRenderingContext,
const nsRect& aDirtyRect, nsPoint aPt);
- void PrintPlugin(nsRenderingContext& aRenderingContext,
+ void PrintPlugin(gfxContext& aRenderingContext,
const nsRect& aDirtyRect);
void PaintPlugin(nsDisplayListBuilder* aBuilder,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
const nsRect& aDirtyRect, const nsRect& aPluginRect);
void NotifyPluginReflowObservers();
friend class nsPluginInstanceOwner;
friend class nsDisplayPlugin;
friend class PluginBackgroundSink;
@@ -347,17 +347,17 @@ public:
MOZ_COUNT_DTOR(nsDisplayPlugin);
}
#endif
virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder, bool* aSnap) override;
virtual nsRegion GetOpaqueRegion(nsDisplayListBuilder* aBuilder,
bool* aSnap) override;
virtual void Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) override;
+ gfxContext* aCtx) override;
virtual bool ComputeVisibility(nsDisplayListBuilder* aBuilder,
nsRegion* aVisibleRegion) override;
NS_DISPLAY_DECL_NAME("Plugin", TYPE_PLUGIN)
virtual already_AddRefed<Layer> BuildLayer(nsDisplayListBuilder* aBuilder,
LayerManager* aManager,
const ContainerLayerParameters& aContainerParameters) override
--- a/layout/generic/nsRubyBaseContainerFrame.cpp
+++ b/layout/generic/nsRubyBaseContainerFrame.cpp
@@ -126,17 +126,17 @@ GetIsLineBreakAllowed(nsIFrame* aFrame,
* @param aBaseISizeData is an in/out param. This method updates the
* `skipWhitespace` and `trailingWhitespace` fields of the struct with
* the base level frame. Note that we don't need to do the same thing
* for ruby text frames, because they are text run container themselves
* (see nsTextFrame.cpp:BuildTextRuns), and thus no whitespace collapse
* happens across the boundary of those frames.
*/
static nscoord
-CalculateColumnPrefISize(nsRenderingContext* aRenderingContext,
+CalculateColumnPrefISize(gfxContext* aRenderingContext,
const RubyColumnEnumerator& aEnumerator,
nsIFrame::InlineIntrinsicISizeData* aBaseISizeData)
{
nscoord max = 0;
uint32_t levelCount = aEnumerator.GetLevelCount();
for (uint32_t i = 0; i < levelCount; i++) {
nsIFrame* frame = aEnumerator.GetFrameAtLevel(i);
if (frame) {
@@ -162,17 +162,17 @@ CalculateColumnPrefISize(nsRenderingCont
return max;
}
// FIXME Currently we use pref isize of ruby content frames for
// computing min isize of ruby frame, which may cause problem.
// See bug 1134945.
/* virtual */ void
nsRubyBaseContainerFrame::AddInlineMinISize(
- nsRenderingContext *aRenderingContext, nsIFrame::InlineMinISizeData *aData)
+ gfxContext *aRenderingContext, nsIFrame::InlineMinISizeData *aData)
{
AutoRubyTextContainerArray textContainers(this);
for (uint32_t i = 0, iend = textContainers.Length(); i < iend; i++) {
if (textContainers[i]->IsSpanContainer()) {
// Since spans are not breakable internally, use our pref isize
// directly if there is any span.
nsIFrame::InlinePrefISizeData data;
@@ -217,17 +217,17 @@ nsRubyBaseContainerFrame::AddInlineMinIS
aData->mAtStartOfLine = false;
}
}
}
}
/* virtual */ void
nsRubyBaseContainerFrame::AddInlinePrefISize(
- nsRenderingContext *aRenderingContext, nsIFrame::InlinePrefISizeData *aData)
+ gfxContext *aRenderingContext, nsIFrame::InlinePrefISizeData *aData)
{
AutoRubyTextContainerArray textContainers(this);
nscoord sum = 0;
for (nsIFrame* frame = this; frame; frame = frame->GetNextInFlow()) {
RubyColumnEnumerator enumerator(
static_cast<nsRubyBaseContainerFrame*>(frame), textContainers);
for (; !enumerator.AtEnd(); enumerator.Next()) {
@@ -258,17 +258,17 @@ nsRubyBaseContainerFrame::IsFrameOfType(
/* virtual */ bool
nsRubyBaseContainerFrame::CanContinueTextRun() const
{
return true;
}
/* virtual */ LogicalSize
-nsRubyBaseContainerFrame::ComputeSize(nsRenderingContext *aRenderingContext,
+nsRubyBaseContainerFrame::ComputeSize(gfxContext *aRenderingContext,
WritingMode aWM,
const LogicalSize& aCBSize,
nscoord aAvailableISize,
const LogicalSize& aMargin,
const LogicalSize& aBorder,
const LogicalSize& aPadding,
ComputeSizeFlags aFlags)
{
--- a/layout/generic/nsRubyBaseContainerFrame.h
+++ b/layout/generic/nsRubyBaseContainerFrame.h
@@ -23,22 +23,22 @@ class nsRubyBaseContainerFrame final : p
{
public:
NS_DECL_FRAMEARENA_HELPERS(nsRubyBaseContainerFrame)
NS_DECL_QUERYFRAME
// nsIFrame overrides
virtual bool IsFrameOfType(uint32_t aFlags) const override;
virtual bool CanContinueTextRun() const override;
- virtual void AddInlineMinISize(nsRenderingContext *aRenderingContext,
+ virtual void AddInlineMinISize(gfxContext *aRenderingContext,
InlineMinISizeData *aData) override;
- virtual void AddInlinePrefISize(nsRenderingContext *aRenderingContext,
+ virtual void AddInlinePrefISize(gfxContext *aRenderingContext,
InlinePrefISizeData *aData) override;
virtual mozilla::LogicalSize
- ComputeSize(nsRenderingContext *aRenderingContext,
+ ComputeSize(gfxContext *aRenderingContext,
mozilla::WritingMode aWritingMode,
const mozilla::LogicalSize& aCBSize,
nscoord aAvailableISize,
const mozilla::LogicalSize& aMargin,
const mozilla::LogicalSize& aBorder,
const mozilla::LogicalSize& aPadding,
ComputeSizeFlags aFlags) override;
virtual void Reflow(nsPresContext* aPresContext,
--- a/layout/generic/nsRubyFrame.cpp
+++ b/layout/generic/nsRubyFrame.cpp
@@ -55,29 +55,29 @@ nsRubyFrame::IsFrameOfType(uint32_t aFla
nsresult
nsRubyFrame::GetFrameName(nsAString& aResult) const
{
return MakeFrameName(NS_LITERAL_STRING("Ruby"), aResult);
}
#endif
/* virtual */ void
-nsRubyFrame::AddInlineMinISize(nsRenderingContext *aRenderingContext,
+nsRubyFrame::AddInlineMinISize(gfxContext *aRenderingContext,
nsIFrame::InlineMinISizeData *aData)
{
for (nsIFrame* frame = this; frame; frame = frame->GetNextInFlow()) {
for (RubySegmentEnumerator e(static_cast<nsRubyFrame*>(frame));
!e.AtEnd(); e.Next()) {
e.GetBaseContainer()->AddInlineMinISize(aRenderingContext, aData);
}
}
}
/* virtual */ void
-nsRubyFrame::AddInlinePrefISize(nsRenderingContext *aRenderingContext,
+nsRubyFrame::AddInlinePrefISize(gfxContext *aRenderingContext,
nsIFrame::InlinePrefISizeData *aData)
{
for (nsIFrame* frame = this; frame; frame = frame->GetNextInFlow()) {
for (RubySegmentEnumerator e(static_cast<nsRubyFrame*>(frame));
!e.AtEnd(); e.Next()) {
e.GetBaseContainer()->AddInlinePrefISize(aRenderingContext, aData);
}
}
--- a/layout/generic/nsRubyFrame.h
+++ b/layout/generic/nsRubyFrame.h
@@ -22,19 +22,19 @@ nsContainerFrame* NS_NewRubyFrame(nsIPre
class nsRubyFrame final : public nsInlineFrame
{
public:
NS_DECL_FRAMEARENA_HELPERS(nsRubyFrame)
NS_DECL_QUERYFRAME
// nsIFrame overrides
virtual bool IsFrameOfType(uint32_t aFlags) const override;
- virtual void AddInlineMinISize(nsRenderingContext *aRenderingContext,
+ virtual void AddInlineMinISize(gfxContext *aRenderingContext,
InlineMinISizeData *aData) override;
- virtual void AddInlinePrefISize(nsRenderingContext *aRenderingContext,
+ virtual void AddInlinePrefISize(gfxContext *aRenderingContext,
InlinePrefISizeData *aData) override;
virtual void Reflow(nsPresContext* aPresContext,
ReflowOutput& aDesiredSize,
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus) override;
#ifdef DEBUG_FRAME_DUMP
virtual nsresult GetFrameName(nsAString& aResult) const override;
--- a/layout/generic/nsSimplePageSequenceFrame.cpp
+++ b/layout/generic/nsSimplePageSequenceFrame.cpp
@@ -5,17 +5,16 @@
#include "nsSimplePageSequenceFrame.h"
#include "DateTimeFormat.h"
#include "nsCOMPtr.h"
#include "nsDeviceContext.h"
#include "nsPresContext.h"
#include "gfxContext.h"
-#include "nsRenderingContext.h"
#include "nsGkAtoms.h"
#include "nsIPresShell.h"
#include "nsIPrintSettings.h"
#include "nsPageFrame.h"
#include "nsSubDocumentFrame.h"
#include "nsRegion.h"
#include "nsCSSFrameConstructor.h"
#include "nsContentUtils.h"
@@ -767,21 +766,19 @@ nsSimplePageSequenceFrame::PrintNextPage
}
PR_PL(("SeqFr::PrintNextPage -> %p PageNo: %d", pf, mPageNum));
// CreateRenderingContext can fail
RefPtr<gfxContext> gCtx = dc->CreateRenderingContext();
NS_ENSURE_TRUE(gCtx, NS_ERROR_OUT_OF_MEMORY);
- nsRenderingContext renderingContext(gCtx);
-
nsRect drawingRect(nsPoint(0, 0), currentPageFrame->GetSize());
nsRegion drawingRegion(drawingRect);
- nsLayoutUtils::PaintFrame(&renderingContext, currentPageFrame,
+ nsLayoutUtils::PaintFrame(gCtx, currentPageFrame,
drawingRegion, NS_RGBA(0,0,0,0),
nsDisplayListBuilderMode::PAINTING,
nsLayoutUtils::PaintFrameFlags::PAINT_SYNC_DECODE_IMAGES);
if (mSelectionHeight >= 0) {
haveUnfinishedSelectionToPrint = (selectionY < mSelectionHeight);
if (haveUnfinishedSelectionToPrint) {
selectionY += pageContentHeight;
--- a/layout/generic/nsSubDocumentFrame.cpp
+++ b/layout/generic/nsSubDocumentFrame.cpp
@@ -639,33 +639,33 @@ nsSubDocumentFrame::List(FILE* out, cons
nsresult nsSubDocumentFrame::GetFrameName(nsAString& aResult) const
{
return MakeFrameName(NS_LITERAL_STRING("FrameOuter"), aResult);
}
#endif
/* virtual */ nscoord
-nsSubDocumentFrame::GetMinISize(nsRenderingContext *aRenderingContext)
+nsSubDocumentFrame::GetMinISize(gfxContext *aRenderingContext)
{
nscoord result;
DISPLAY_MIN_WIDTH(this, result);
nsIFrame* subDocRoot = ObtainIntrinsicSizeFrame();
if (subDocRoot) {
result = subDocRoot->GetMinISize(aRenderingContext);
} else {
result = GetIntrinsicISize();
}
return result;
}
/* virtual */ nscoord
-nsSubDocumentFrame::GetPrefISize(nsRenderingContext *aRenderingContext)
+nsSubDocumentFrame::GetPrefISize(gfxContext *aRenderingContext)
{
nscoord result;
DISPLAY_PREF_WIDTH(this, result);
nsIFrame* subDocRoot = ObtainIntrinsicSizeFrame();
if (subDocRoot) {
result = subDocRoot->GetPrefISize(aRenderingContext);
} else {
@@ -692,17 +692,17 @@ nsSubDocumentFrame::GetIntrinsicRatio()
if (subDocRoot) {
return subDocRoot->GetIntrinsicRatio();
}
return nsAtomicContainerFrame::GetIntrinsicRatio();
}
/* virtual */
LogicalSize
-nsSubDocumentFrame::ComputeAutoSize(nsRenderingContext* aRenderingContext,
+nsSubDocumentFrame::ComputeAutoSize(gfxContext* aRenderingContext,
WritingMode aWM,
const LogicalSize& aCBSize,
nscoord aAvailableISize,
const LogicalSize& aMargin,
const LogicalSize& aBorder,
const LogicalSize& aPadding,
ComputeSizeFlags aFlags)
{
@@ -715,17 +715,17 @@ nsSubDocumentFrame::ComputeAutoSize(nsRe
const WritingMode wm = GetWritingMode();
LogicalSize result(wm, GetIntrinsicISize(), GetIntrinsicBSize());
return result.ConvertTo(aWM, wm);
}
/* virtual */
LogicalSize
-nsSubDocumentFrame::ComputeSize(nsRenderingContext* aRenderingContext,
+nsSubDocumentFrame::ComputeSize(gfxContext* aRenderingContext,
WritingMode aWM,
const LogicalSize& aCBSize,
nscoord aAvailableISize,
const LogicalSize& aMargin,
const LogicalSize& aBorder,
const LogicalSize& aPadding,
ComputeSizeFlags aFlags)
{
--- a/layout/generic/nsSubDocumentFrame.h
+++ b/layout/generic/nsSubDocumentFrame.h
@@ -40,34 +40,34 @@ public:
}
void Init(nsIContent* aContent,
nsContainerFrame* aParent,
nsIFrame* aPrevInFlow) override;
void DestroyFrom(nsIFrame* aDestructRoot) override;
- nscoord GetMinISize(nsRenderingContext *aRenderingContext) override;
- nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override;
+ nscoord GetMinISize(gfxContext *aRenderingContext) override;
+ nscoord GetPrefISize(gfxContext *aRenderingContext) override;
mozilla::IntrinsicSize GetIntrinsicSize() override;
nsSize GetIntrinsicRatio() override;
mozilla::LogicalSize
- ComputeAutoSize(nsRenderingContext* aRenderingContext,
+ ComputeAutoSize(gfxContext* aRenderingContext,
mozilla::WritingMode aWritingMode,
const mozilla::LogicalSize& aCBSize,
nscoord aAvailableISize,
const mozilla::LogicalSize& aMargin,
const mozilla::LogicalSize& aBorder,
const mozilla::LogicalSize& aPadding,
ComputeSizeFlags aFlags) override;
mozilla::LogicalSize
- ComputeSize(nsRenderingContext* aRenderingContext,
+ ComputeSize(gfxContext* aRenderingContext,
mozilla::WritingMode aWritingMode,
const mozilla::LogicalSize& aCBSize,
nscoord aAvailableISize,
const mozilla::LogicalSize& aMargin,
const mozilla::LogicalSize& aBorder,
const mozilla::LogicalSize& aPadding,
ComputeSizeFlags aFlags) override;
--- a/layout/generic/nsTextFrame.cpp
+++ b/layout/generic/nsTextFrame.cpp
@@ -32,17 +32,17 @@
#include "nsPresContext.h"
#include "nsIContent.h"
#include "nsStyleConsts.h"
#include "nsStyleContext.h"
#include "nsStyleStruct.h"
#include "nsStyleStructInlines.h"
#include "SVGTextFrame.h"
#include "nsCoord.h"
-#include "nsRenderingContext.h"
+#include "gfxContext.h"
#include "nsIPresShell.h"
#include "nsTArray.h"
#include "nsCSSPseudoElements.h"
#include "nsCSSFrameConstructor.h"
#include "nsCompatibility.h"
#include "nsCSSColorUtils.h"
#include "nsLayoutUtils.h"
#include "nsDisplayList.h"
@@ -4424,19 +4424,19 @@ public:
NS_ASSERTION (!nsSplittableFrame::IsInPrevContinuationChain(aPrevInFlow, this),
"creating a loop in continuation chain!");
mPrevContinuation = static_cast<nsTextFrame*>(aPrevInFlow);
AddStateBits(NS_FRAME_IS_FLUID_CONTINUATION);
}
nsIFrame* FirstInFlow() const override;
nsIFrame* FirstContinuation() const override;
- void AddInlineMinISize(nsRenderingContext* aRenderingContext,
+ void AddInlineMinISize(gfxContext* aRenderingContext,
InlineMinISizeData* aData) override;
- void AddInlinePrefISize(nsRenderingContext* aRenderingContext,
+ void AddInlinePrefISize(gfxContext* aRenderingContext,
InlinePrefISizeData* aData) override;
protected:
explicit nsContinuingTextFrame(nsStyleContext* aContext)
: nsTextFrame(aContext, kClassID)
{}
nsTextFrame* mPrevContinuation;
@@ -4572,38 +4572,38 @@ nsContinuingTextFrame::FirstContinuation
// but depends on our maintining the frame tree in reasonable ways even
// for edge cases (block-within-inline splits, nextBidi, etc.)
// XXX We really need to make :first-letter happen during frame
// construction.
// Needed for text frames in XUL.
/* virtual */ nscoord
-nsTextFrame::GetMinISize(nsRenderingContext *aRenderingContext)
+nsTextFrame::GetMinISize(gfxContext *aRenderingContext)
{
return nsLayoutUtils::MinISizeFromInline(this, aRenderingContext);
}
// Needed for text frames in XUL.
/* virtual */ nscoord
-nsTextFrame::GetPrefISize(nsRenderingContext *aRenderingContext)
+nsTextFrame::GetPrefISize(gfxContext *aRenderingContext)
{
return nsLayoutUtils::PrefISizeFromInline(this, aRenderingContext);
}
/* virtual */ void
-nsContinuingTextFrame::AddInlineMinISize(nsRenderingContext *aRenderingContext,
+nsContinuingTextFrame::AddInlineMinISize(gfxContext *aRenderingContext,
InlineMinISizeData *aData)
{
// Do nothing, since the first-in-flow accounts for everything.
return;
}
/* virtual */ void
-nsContinuingTextFrame::AddInlinePrefISize(nsRenderingContext *aRenderingContext,
+nsContinuingTextFrame::AddInlinePrefISize(gfxContext *aRenderingContext,
InlinePrefISizeData *aData)
{
// Do nothing, since the first-in-flow accounts for everything.
return;
}
//----------------------------------------------------------------------
@@ -4890,17 +4890,17 @@ public:
}
virtual LayerState GetLayerState(nsDisplayListBuilder* aBuilder,
LayerManager* aManager,
const ContainerLayerParameters& aParameters) override;
virtual already_AddRefed<Layer> BuildLayer(nsDisplayListBuilder* aBuilder,
LayerManager* aManager,
const ContainerLayerParameters& aContainerParameters) override;
virtual void Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) override;
+ gfxContext* aCtx) override;
NS_DISPLAY_DECL_NAME("Text", TYPE_TEXT)
virtual nsRect GetComponentAlphaBounds(nsDisplayListBuilder* aBuilder) override
{
if (gfxPlatform::GetPlatform()->RespectsFontStyleSmoothing()) {
// On OS X, web authors can turn off subpixel text rendering using the
// CSS property -moz-osx-font-smoothing. If they do that, we don't need
// to use component alpha layers for the affected text.
@@ -5122,25 +5122,25 @@ nsDisplayText::GetLayerState(nsDisplayLi
return mozilla::LAYER_ACTIVE;
}
MOZ_ASSERT(mMergedFrames.IsEmpty());
return mozilla::LAYER_NONE;
}
void
nsDisplayText::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) {
+ gfxContext* aCtx) {
PROFILER_LABEL("nsDisplayText", "Paint",
js::ProfileEntry::Category::GRAPHICS);
MOZ_ASSERT(mMergedFrames.IsEmpty());
DrawTargetAutoDisableSubpixelAntialiasing disable(aCtx->GetDrawTarget(),
mDisableSubpixelAA);
- RenderToContext(aCtx->ThebesContext(), aBuilder);
+ RenderToContext(aCtx, aBuilder);
}
already_AddRefed<layers::Layer>
nsDisplayText::BuildLayer(nsDisplayListBuilder* aBuilder,
LayerManager* aManager,
const ContainerLayerParameters& aContainerParameters)
{
// We should have all the glyphs recorded now, build
@@ -8414,17 +8414,17 @@ void nsTextFrame::MarkIntrinsicISizesDir
{
ClearTextRuns();
nsFrame::MarkIntrinsicISizesDirty();
}
// XXX this doesn't handle characters shaped by line endings. We need to
// temporarily override the "current line ending" settings.
void
-nsTextFrame::AddInlineMinISizeForFlow(nsRenderingContext *aRenderingContext,
+nsTextFrame::AddInlineMinISizeForFlow(gfxContext *aRenderingContext,
nsIFrame::InlineMinISizeData *aData,
TextRunType aTextRunType)
{
uint32_t flowEndInTextRun;
gfxSkipCharsIterator iter =
EnsureTextRun(aTextRunType, aRenderingContext->GetDrawTarget(),
aData->LineContainer(), aData->mLine, &flowEndInTextRun);
gfxTextRun *textRun = GetTextRun(aTextRunType);
@@ -8559,17 +8559,17 @@ nsTextFrame::AddInlineMinISizeForFlow(ns
bool nsTextFrame::IsCurrentFontInflation(float aInflation) const {
return fabsf(aInflation - GetFontSizeInflation()) < 1e-6;
}
// XXX Need to do something here to avoid incremental reflow bugs due to
// first-line and first-letter changing min-width
/* virtual */ void
-nsTextFrame::AddInlineMinISize(nsRenderingContext *aRenderingContext,
+nsTextFrame::AddInlineMinISize(gfxContext *aRenderingContext,
nsIFrame::InlineMinISizeData *aData)
{
float inflation = nsLayoutUtils::FontSizeInflationFor(this);
TextRunType trtype = (inflation == 1.0f) ? eNotInflated : eInflated;
if (trtype == eInflated && !IsCurrentFontInflation(inflation)) {
// FIXME: Ideally, if we already have a text run, we'd move it to be
// the uninflated text run.
@@ -8599,17 +8599,17 @@ nsTextFrame::AddInlineMinISize(nsRenderi
lastTextRun = f->GetTextRun(trtype);
}
}
}
// XXX this doesn't handle characters shaped by line endings. We need to
// temporarily override the "current line ending" settings.
void
-nsTextFrame::AddInlinePrefISizeForFlow(nsRenderingContext *aRenderingContext,
+nsTextFrame::AddInlinePrefISizeForFlow(gfxContext *aRenderingContext,
nsIFrame::InlinePrefISizeData *aData,
TextRunType aTextRunType)
{
uint32_t flowEndInTextRun;
gfxSkipCharsIterator iter =
EnsureTextRun(aTextRunType, aRenderingContext->GetDrawTarget(),
aData->LineContainer(), aData->mLine, &flowEndInTextRun);
gfxTextRun *textRun = GetTextRun(aTextRunType);
@@ -8710,17 +8710,17 @@ nsTextFrame::AddInlinePrefISizeForFlow(n
iter.ConvertSkippedToOriginal(flowEndInTextRun - 1),
textStyle);
}
}
// XXX Need to do something here to avoid incremental reflow bugs due to
// first-line and first-letter changing pref-width
/* virtual */ void
-nsTextFrame::AddInlinePrefISize(nsRenderingContext *aRenderingContext,
+nsTextFrame::AddInlinePrefISize(gfxContext *aRenderingContext,
nsIFrame::InlinePrefISizeData *aData)
{
float inflation = nsLayoutUtils::FontSizeInflationFor(this);
TextRunType trtype = (inflation == 1.0f) ? eNotInflated : eInflated;
if (trtype == eInflated && !IsCurrentFontInflation(inflation)) {
// FIXME: Ideally, if we already have a text run, we'd move it to be
// the uninflated text run.
@@ -8749,17 +8749,17 @@ nsTextFrame::AddInlinePrefISize(nsRender
f->AddInlinePrefISizeForFlow(aRenderingContext, aData, trtype);
lastTextRun = f->GetTextRun(trtype);
}
}
}
/* virtual */
LogicalSize
-nsTextFrame::ComputeSize(nsRenderingContext *aRenderingContext,
+nsTextFrame::ComputeSize(gfxContext *aRenderingContext,
WritingMode aWM,
const LogicalSize& aCBSize,
nscoord aAvailableISize,
const LogicalSize& aMargin,
const LogicalSize& aBorder,
const LogicalSize& aPadding,
ComputeSizeFlags aFlags)
{
@@ -8812,17 +8812,17 @@ nsTextFrame::ComputeTightBounds(DrawTarg
// Swap line-relative textMetrics dimensions to physical coordinates.
Swap(boundingBox.x, boundingBox.y);
Swap(boundingBox.width, boundingBox.height);
}
return boundingBox;
}
/* virtual */ nsresult
-nsTextFrame::GetPrefWidthTightBounds(nsRenderingContext* aContext,
+nsTextFrame::GetPrefWidthTightBounds(gfxContext* aContext,
nscoord* aX,
nscoord* aXMost)
{
gfxSkipCharsIterator iter =
const_cast<nsTextFrame*>(this)->EnsureTextRun(nsTextFrame::eInflated);
if (!mTextRun)
return NS_ERROR_FAILURE;
--- a/layout/generic/nsTextFrame.h
+++ b/layout/generic/nsTextFrame.h
@@ -260,32 +260,32 @@ public:
bool IsCurrentFontInflation(float aInflation) const;
bool HasFontSizeInflation() const
{
return (GetStateBits() & TEXT_HAS_FONT_INFLATION) != 0;
}
void SetFontSizeInflation(float aInflation);
void MarkIntrinsicISizesDirty() override;
- nscoord GetMinISize(nsRenderingContext* aRenderingContext) override;
- nscoord GetPrefISize(nsRenderingContext* aRenderingContext) override;
- void AddInlineMinISize(nsRenderingContext* aRenderingContext,
+ nscoord GetMinISize(gfxContext* aRenderingContext) override;
+ nscoord GetPrefISize(gfxContext* aRenderingContext) override;
+ void AddInlineMinISize(gfxContext* aRenderingContext,
InlineMinISizeData* aData) override;
- void AddInlinePrefISize(nsRenderingContext* aRenderingContext,
+ void AddInlinePrefISize(gfxContext* aRenderingContext,
InlinePrefISizeData* aData) override;
- mozilla::LogicalSize ComputeSize(nsRenderingContext* aRenderingContext,
+ mozilla::LogicalSize ComputeSize(gfxContext* aRenderingContext,
mozilla::WritingMode aWritingMode,
const mozilla::LogicalSize& aCBSize,
nscoord aAvailableISize,
const mozilla::LogicalSize& aMargin,
const mozilla::LogicalSize& aBorder,
const mozilla::LogicalSize& aPadding,
ComputeSizeFlags aFlags) override;
nsRect ComputeTightBounds(DrawTarget* aDrawTarget) const override;
- nsresult GetPrefWidthTightBounds(nsRenderingContext* aContext,
+ nsresult GetPrefWidthTightBounds(gfxContext* aContext,
nscoord* aX,
nscoord* aXMost) override;
void Reflow(nsPresContext* aPresContext,
ReflowOutput& aMetrics,
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus) override;
bool CanContinueTextRun() const override;
// Method that is called for a text frame that is logically
@@ -315,20 +315,20 @@ public:
// painting should use the inflated text run (i.e., with font size
// inflation applied).
eInflated,
// Intrinsic width calculation should use the non-inflated text run.
// When there is font size inflation, it will be different.
eNotInflated
};
- void AddInlineMinISizeForFlow(nsRenderingContext* aRenderingContext,
+ void AddInlineMinISizeForFlow(gfxContext* aRenderingContext,
nsIFrame::InlineMinISizeData* aData,
TextRunType aTextRunType);
- void AddInlinePrefISizeForFlow(nsRenderingContext* aRenderingContext,
+ void AddInlinePrefISizeForFlow(gfxContext* aRenderingContext,
InlinePrefISizeData* aData,
TextRunType aTextRunType);
/**
* Calculate the horizontal bounds of the grapheme clusters that fit entirely
* inside the given left[top]/right[bottom] edges (which are positive lengths
* from the respective frame edge). If an input value is zero it is ignored
* and the result for that edge is zero. All out parameter values are
--- a/layout/generic/nsVideoFrame.cpp
+++ b/layout/generic/nsVideoFrame.cpp
@@ -532,17 +532,17 @@ nsVideoFrame::AccessibleType()
nsresult
nsVideoFrame::GetFrameName(nsAString& aResult) const
{
return MakeFrameName(NS_LITERAL_STRING("HTMLVideo"), aResult);
}
#endif
LogicalSize
-nsVideoFrame::ComputeSize(nsRenderingContext *aRenderingContext,
+nsVideoFrame::ComputeSize(gfxContext *aRenderingContext,
WritingMode aWM,
const LogicalSize& aCBSize,
nscoord aAvailableISize,
const LogicalSize& aMargin,
const LogicalSize& aBorder,
const LogicalSize& aPadding,
ComputeSizeFlags aFlags)
{
@@ -572,17 +572,17 @@ nsVideoFrame::ComputeSize(nsRenderingCon
nsSize intrinsicRatio = HasVideoElement() ? size : nsSize(0, 0);
return ComputeSizeWithIntrinsicDimensions(aRenderingContext, aWM,
intrinsicSize, intrinsicRatio,
aCBSize, aMargin, aBorder, aPadding,
aFlags);
}
-nscoord nsVideoFrame::GetMinISize(nsRenderingContext *aRenderingContext)
+nscoord nsVideoFrame::GetMinISize(gfxContext *aRenderingContext)
{
nscoord result;
DISPLAY_MIN_WIDTH(this, result);
if (HasVideoElement()) {
nsSize size = GetVideoIntrinsicSize(aRenderingContext);
result = GetWritingMode().IsVertical() ? size.height : size.width;
} else {
@@ -596,17 +596,17 @@ nscoord nsVideoFrame::GetMinISize(nsRend
} else {
result = 0;
}
}
return result;
}
-nscoord nsVideoFrame::GetPrefISize(nsRenderingContext *aRenderingContext)
+nscoord nsVideoFrame::GetPrefISize(gfxContext *aRenderingContext)
{
nscoord result;
DISPLAY_PREF_WIDTH(this, result);
if (HasVideoElement()) {
nsSize size = GetVideoIntrinsicSize(aRenderingContext);
result = GetWritingMode().IsVertical() ? size.height : size.width;
} else {
@@ -658,17 +658,17 @@ bool nsVideoFrame::ShouldDisplayPoster()
res = request->GetImageStatus(&status);
if (NS_FAILED(res) || (status & imgIRequest::STATUS_ERROR))
return false;
return true;
}
nsSize
-nsVideoFrame::GetVideoIntrinsicSize(nsRenderingContext *aRenderingContext)
+nsVideoFrame::GetVideoIntrinsicSize(gfxContext *aRenderingContext)
{
// Defaulting size to 300x150 if no size given.
nsIntSize size(300, 150);
// All media controls have been converted to HTML except Android. Hence
// we keep this codepath for Android until removal in bug 1310907.
#ifdef ANDROID
if (!HasVideoElement()) {
--- a/layout/generic/nsVideoFrame.h
+++ b/layout/generic/nsVideoFrame.h
@@ -50,29 +50,29 @@ public:
nsresult AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType) override;
void OnVisibilityChange(Visibility aNewVisibility,
const Maybe<OnNonvisible>& aNonvisibleAction = Nothing()) override;
/* get the size of the video's display */
- nsSize GetVideoIntrinsicSize(nsRenderingContext *aRenderingContext);
+ nsSize GetVideoIntrinsicSize(gfxContext *aRenderingContext);
nsSize GetIntrinsicRatio() override;
mozilla::LogicalSize
- ComputeSize(nsRenderingContext *aRenderingContext,
+ ComputeSize(gfxContext *aRenderingContext,
mozilla::WritingMode aWritingMode,
const mozilla::LogicalSize& aCBSize,
nscoord aAvailableISize,
const mozilla::LogicalSize& aMargin,
const mozilla::LogicalSize& aBorder,
const mozilla::LogicalSize& aPadding,
ComputeSizeFlags aFlags) override;
- nscoord GetMinISize(nsRenderingContext *aRenderingContext) override;
- nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override;
+ nscoord GetMinISize(gfxContext *aRenderingContext) override;
+ nscoord GetPrefISize(gfxContext *aRenderingContext) override;
void DestroyFrom(nsIFrame* aDestructRoot) override;
void Reflow(nsPresContext* aPresContext,
ReflowOutput& aDesiredSize,
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus) override;
#ifdef ACCESSIBILITY
--- a/layout/mathml/nsIMathMLFrame.h
+++ b/layout/mathml/nsIMathMLFrame.h
@@ -6,17 +6,17 @@
#ifndef nsIMathMLFrame_h___
#define nsIMathMLFrame_h___
#include "nsQueryFrame.h"
#include "nsMathMLOperators.h"
struct nsPresentationData;
struct nsEmbellishData;
-class nsRenderingContext;
+class gfxContext;
class nsIFrame;
namespace mozilla {
class ReflowOutput;
} // namespace mozilla
// For MathML, this 'type' will be used to determine the spacing between frames
// Subclasses can return a 'type' that will give them a particular spacing
enum eMathMLFrameType {
--- a/layout/mathml/nsMathMLChar.cpp
+++ b/layout/mathml/nsMathMLChar.cpp
@@ -1,31 +1,31 @@
/* -*- 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 "nsMathMLChar.h"
+#include "gfxContext.h"
#include "gfxTextRun.h"
#include "gfxUtils.h"
#include "mozilla/gfx/2D.h"
#include "mozilla/MathAlgorithms.h"
#include "mozilla/Unused.h"
#include "nsAutoPtr.h"
#include "nsCOMPtr.h"
#include "nsDeviceContext.h"
#include "nsFontMetrics.h"
#include "nsIFrame.h"
#include "nsLayoutUtils.h"
#include "nsPresContext.h"
#include "nsStyleContext.h"
#include "nsUnicharUtils.h"
-#include "nsRenderingContext.h"
#include "mozilla/Preferences.h"
#include "nsIPersistentProperties2.h"
#include "nsIObserverService.h"
#include "nsIObserver.h"
#include "nsNetUtil.h"
#include "nsContentUtils.h"
@@ -1831,24 +1831,24 @@ public:
}
#ifdef NS_BUILD_REFCNT_LOGGING
virtual ~nsDisplayMathMLSelectionRect() {
MOZ_COUNT_DTOR(nsDisplayMathMLSelectionRect);
}
#endif
virtual void Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) override;
+ gfxContext* aCtx) override;
NS_DISPLAY_DECL_NAME("MathMLSelectionRect", TYPE_MATHML_SELECTION_RECT)
private:
nsRect mRect;
};
void nsDisplayMathMLSelectionRect::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx)
+ gfxContext* aCtx)
{
DrawTarget* drawTarget = aCtx->GetDrawTarget();
Rect rect = NSRectToSnappedRect(mRect + ToReferenceFrame(),
mFrame->PresContext()->AppUnitsPerDevPixel(),
*drawTarget);
// get color to use for selection from the look&feel object
nscolor bgColor =
LookAndFeel::GetColor(LookAndFeel::eColorID_TextSelectBackground,
@@ -1881,17 +1881,17 @@ public:
nsRect temp(offset.x + bm.leftBearing, offset.y,
bm.rightBearing - bm.leftBearing, bm.ascent + bm.descent);
// Bug 748220
temp.Inflate(mFrame->PresContext()->AppUnitsPerDevPixel());
return temp;
}
virtual void Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) override
+ gfxContext* aCtx) override
{
mChar->PaintForeground(mFrame->PresContext(), *aCtx,
ToReferenceFrame(), mIsSelected);
}
NS_DISPLAY_DECL_NAME("MathMLCharForeground", TYPE_MATHML_CHAR_FOREGROUND)
virtual nsRect GetComponentAlphaBounds(nsDisplayListBuilder* aBuilder) override
@@ -1921,25 +1921,25 @@ public:
}
#ifdef NS_BUILD_REFCNT_LOGGING
virtual ~nsDisplayMathMLCharDebug() {
MOZ_COUNT_DTOR(nsDisplayMathMLCharDebug);
}
#endif
virtual void Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) override;
+ gfxContext* aCtx) override;
NS_DISPLAY_DECL_NAME("MathMLCharDebug", TYPE_MATHML_CHAR_DEBUG)
private:
nsRect mRect;
};
void nsDisplayMathMLCharDebug::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx)
+ gfxContext* aCtx)
{
// for visual debug
Sides skipSides;
nsPresContext* presContext = mFrame->PresContext();
nsStyleContext* styleContext = mFrame->StyleContext();
nsRect rect = mRect + ToReferenceFrame();
PaintBorderFlags flags = aBuilder->ShouldSyncDecodeImages()
@@ -2034,69 +2034,67 @@ nsMathMLChar::ApplyTransforms(gfxContext
// update the bounding rectangle.
r.x = r.y = 0;
r.width /= mScaleX;
r.height /= mScaleY;
}
void
nsMathMLChar::PaintForeground(nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
nsPoint aPt,
bool aIsSelected)
{
nsStyleContext* parentContext = mStyleContext->GetParentAllowServo();
nsStyleContext* styleContext = mStyleContext;
if (mDraw == DRAW_NORMAL) {
// normal drawing if there is nothing special about this char
// Set default context to the parent context
styleContext = parentContext;
}
- RefPtr<gfxContext> thebesContext = aRenderingContext.ThebesContext();
-
// Set color ...
nscolor fgColor = styleContext->
GetVisitedDependentColor(&nsStyleText::mWebkitTextFillColor);
if (aIsSelected) {
// get color to use for selection from the look&feel object
fgColor = LookAndFeel::GetColor(LookAndFeel::eColorID_TextSelectForeground,
fgColor);
}
- thebesContext->SetColor(Color::FromABGR(fgColor));
- thebesContext->Save();
+ aRenderingContext.SetColor(Color::FromABGR(fgColor));
+ aRenderingContext.Save();
nsRect r = mRect + aPt;
- ApplyTransforms(thebesContext, aPresContext->AppUnitsPerDevPixel(), r);
+ ApplyTransforms(&aRenderingContext, aPresContext->AppUnitsPerDevPixel(), r);
switch(mDraw)
{
case DRAW_NORMAL:
case DRAW_VARIANT:
// draw a single glyph (base size or size variant)
// XXXfredw verify if mGlyphs[0] is non-null to workaround bug 973322.
if (mGlyphs[0]) {
mGlyphs[0]->Draw(Range(mGlyphs[0].get()), gfxPoint(0.0, mUnscaledAscent),
- gfxTextRun::DrawParams(thebesContext));
+ gfxTextRun::DrawParams(&aRenderingContext));
}
break;
case DRAW_PARTS: {
// paint by parts
if (NS_STRETCH_DIRECTION_VERTICAL == mDirection)
- PaintVertically(aPresContext, thebesContext, r, fgColor);
+ PaintVertically(aPresContext, &aRenderingContext, r, fgColor);
else if (NS_STRETCH_DIRECTION_HORIZONTAL == mDirection)
- PaintHorizontally(aPresContext, thebesContext, r, fgColor);
+ PaintHorizontally(aPresContext, &aRenderingContext, r, fgColor);
break;
}
default:
NS_NOTREACHED("Unknown drawing method");
break;
}
- thebesContext->Restore();
+ aRenderingContext.Restore();
}
/* =============================================================================
Helper routines that actually do the job of painting the char by parts
*/
class AutoPushClipRect {
gfxContext* mThebesContext;
--- a/layout/mathml/nsMathMLChar.h
+++ b/layout/mathml/nsMathMLChar.h
@@ -9,22 +9,22 @@
#include "nsColor.h"
#include "nsMathMLOperators.h"
#include "nsPoint.h"
#include "nsRect.h"
#include "nsString.h"
#include "nsBoundingMetrics.h"
#include "gfxTextRun.h"
+class gfxContext;
class nsGlyphTable;
class nsIFrame;
class nsDisplayListBuilder;
class nsDisplayListSet;
class nsPresContext;
-class nsRenderingContext;
struct nsBoundingMetrics;
class nsStyleContext;
struct nsFont;
// Hints for Stretch() to indicate criteria for stretching
enum {
// Don't stretch
NS_STRETCH_NONE = 0x00,
@@ -100,19 +100,19 @@ public:
// not a virtual destructor: this class is not intended to be subclassed
~nsMathMLChar();
void Display(nsDisplayListBuilder* aBuilder,
nsIFrame* aForFrame,
const nsDisplayListSet& aLists,
uint32_t aIndex,
const nsRect* aSelectedRect = nullptr);
-
+
void PaintForeground(nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
nsPoint aPt,
bool aIsSelected);
// This is the method called to ask the char to stretch itself.
// @param aContainerSize - IN - suggested size for the stretched char
// @param aDesiredStretchSize - OUT - the size that the char wants
nsresult
Stretch(nsPresContext* aPresContext,
@@ -218,17 +218,17 @@ private:
// - DRAW_VARIANT: we draw a larger size variant given by mGlyphs[0].
// - DRAW_PARTS: we assemble several parts given by mGlyphs[0], ... mGlyphs[4]
// XXXfredw: the MATH table can have any numbers of parts and extenders.
enum DrawingMethod {
DRAW_NORMAL, DRAW_VARIANT, DRAW_PARTS
};
DrawingMethod mDraw;
- // mMirrored indicates whether the character is mirrored.
+ // mMirrored indicates whether the character is mirrored.
bool mMirrored;
class StretchEnumContext;
friend class StretchEnumContext;
// helper methods
bool
SetFontFamily(nsPresContext* aPresContext,
--- a/layout/mathml/nsMathMLContainerFrame.cpp
+++ b/layout/mathml/nsMathMLContainerFrame.cpp
@@ -1,23 +1,23 @@
/* -*- 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 "nsMathMLContainerFrame.h"
+#include "gfxContext.h"
#include "gfxUtils.h"
#include "mozilla/gfx/2D.h"
#include "nsLayoutUtils.h"
#include "nsPresContext.h"
#include "nsIPresShell.h"
#include "nsStyleContext.h"
#include "nsNameSpaceManager.h"
-#include "nsRenderingContext.h"
#include "nsIDOMMutationEvent.h"
#include "nsGkAtoms.h"
#include "nsDisplayList.h"
#include "mozilla/Likely.h"
#include "nsIScriptError.h"
#include "nsContentUtils.h"
#include "nsMathMLElement.h"
@@ -77,37 +77,37 @@ public:
}
#ifdef NS_BUILD_REFCNT_LOGGING
virtual ~nsDisplayMathMLError() {
MOZ_COUNT_DTOR(nsDisplayMathMLError);
}
#endif
virtual void Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) override;
+ gfxContext* aCtx) override;
NS_DISPLAY_DECL_NAME("MathMLError", TYPE_MATHML_ERROR)
};
void nsDisplayMathMLError::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx)
+ gfxContext* aCtx)
{
// Set color and font ...
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)));
drawTarget->FillRect(rect, red);
- aCtx->ThebesContext()->SetColor(Color(1.f, 1.f, 1.f));
+ aCtx->SetColor(Color(1.f, 1.f, 1.f));
nscoord ascent = fm->MaxAscent();
NS_NAMED_LITERAL_STRING(errorMsg, "invalid-markup");
nsLayoutUtils::DrawUniDirString(errorMsg.get(), uint32_t(errorMsg.Length()),
nsPoint(pt.x, pt.y + ascent), *fm, *aCtx);
}
/* /////////////
* nsIMathMLFrame - support methods for stretchy elements
@@ -957,51 +957,51 @@ static nscoord AddInterFrameSpacingToSiz
/* virtual */ void
nsMathMLContainerFrame::MarkIntrinsicISizesDirty()
{
mIntrinsicWidth = NS_INTRINSIC_WIDTH_UNKNOWN;
nsContainerFrame::MarkIntrinsicISizesDirty();
}
void
-nsMathMLContainerFrame::UpdateIntrinsicWidth(nsRenderingContext* aRenderingContext)
+nsMathMLContainerFrame::UpdateIntrinsicWidth(gfxContext* aRenderingContext)
{
if (mIntrinsicWidth == NS_INTRINSIC_WIDTH_UNKNOWN) {
ReflowOutput desiredSize(GetWritingMode());
GetIntrinsicISizeMetrics(aRenderingContext, desiredSize);
// Include the additional width added by FixInterFrameSpacing to ensure
// consistent width calculations.
AddInterFrameSpacingToSize(desiredSize, this);
mIntrinsicWidth = desiredSize.ISize(GetWritingMode());
}
}
/* virtual */ nscoord
-nsMathMLContainerFrame::GetMinISize(nsRenderingContext* aRenderingContext)
+nsMathMLContainerFrame::GetMinISize(gfxContext* aRenderingContext)
{
nscoord result;
DISPLAY_MIN_WIDTH(this, result);
UpdateIntrinsicWidth(aRenderingContext);
result = mIntrinsicWidth;
return result;
}
/* virtual */ nscoord
-nsMathMLContainerFrame::GetPrefISize(nsRenderingContext* aRenderingContext)
+nsMathMLContainerFrame::GetPrefISize(gfxContext* aRenderingContext)
{
nscoord result;
DISPLAY_PREF_WIDTH(this, result);
UpdateIntrinsicWidth(aRenderingContext);
result = mIntrinsicWidth;
return result;
}
/* virtual */ void
-nsMathMLContainerFrame::GetIntrinsicISizeMetrics(nsRenderingContext* aRenderingContext,
+nsMathMLContainerFrame::GetIntrinsicISizeMetrics(gfxContext* aRenderingContext,
ReflowOutput& aDesiredSize)
{
// Get child widths
nsIFrame* childFrame = mFrames.FirstChild();
while (childFrame) {
ReflowOutput childDesiredSize(GetWritingMode()); // ???
nsMathMLContainerFrame* containerFrame = do_QueryFrame(childFrame);
--- a/layout/mathml/nsMathMLContainerFrame.h
+++ b/layout/mathml/nsMathMLContainerFrame.h
@@ -84,24 +84,24 @@ public:
virtual void
RemoveFrame(ChildListID aListID,
nsIFrame* aOldFrame) override;
/**
* Both GetMinISize and GetPrefISize use the intrinsic width metrics
* returned by GetIntrinsicMetrics, including ink overflow.
*/
- virtual nscoord GetMinISize(nsRenderingContext* aRenderingContext) override;
- virtual nscoord GetPrefISize(nsRenderingContext* aRenderingContext) override;
+ virtual nscoord GetMinISize(gfxContext* aRenderingContext) override;
+ virtual nscoord GetPrefISize(gfxContext* aRenderingContext) override;
/**
* Return the intrinsic horizontal metrics of the frame's content area.
*/
virtual void
- GetIntrinsicISizeMetrics(nsRenderingContext* aRenderingContext,
+ GetIntrinsicISizeMetrics(gfxContext* aRenderingContext,
ReflowOutput& aDesiredSize);
virtual void
Reflow(nsPresContext* aPresContext,
ReflowOutput& aDesiredSize,
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus) override;
@@ -375,17 +375,17 @@ protected:
* aStop == nullptr meaning all next siblings with the bit set.
* The method does nothing if aFirst == nullptr.
*/
static void DidReflowChildren(nsIFrame* aFirst, nsIFrame* aStop = nullptr);
/**
* Recompute mIntrinsicWidth if it's not already up to date.
*/
- void UpdateIntrinsicWidth(nsRenderingContext* aRenderingContext);
+ void UpdateIntrinsicWidth(gfxContext* aRenderingContext);
nscoord mIntrinsicWidth;
nscoord mBlockStartAscent;
private:
class RowChildFrameIterator;
friend class RowChildFrameIterator;
--- a/layout/mathml/nsMathMLFrame.cpp
+++ b/layout/mathml/nsMathMLFrame.cpp
@@ -1,29 +1,29 @@
/* -*- 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 "nsMathMLFrame.h"
+#include "gfxContext.h"
#include "gfxUtils.h"
#include "mozilla/gfx/2D.h"
#include "nsLayoutUtils.h"
#include "nsNameSpaceManager.h"
#include "nsMathMLChar.h"
#include "nsCSSPseudoElements.h"
#include "nsMathMLElement.h"
#include "gfxMathTable.h"
// used to map attributes into CSS rules
#include "mozilla/StyleSetHandle.h"
#include "mozilla/StyleSetHandleInlines.h"
#include "nsDisplayList.h"
-#include "nsRenderingContext.h"
using namespace mozilla;
using namespace mozilla::gfx;
eMathMLFrameType
nsMathMLFrame::GetMathMLFrameType()
{
// see if it is an embellished operator (mapped to 'Op' in TeX)
@@ -286,24 +286,24 @@ public:
}
#ifdef NS_BUILD_REFCNT_LOGGING
virtual ~nsDisplayMathMLBoundingMetrics() {
MOZ_COUNT_DTOR(nsDisplayMathMLBoundingMetrics);
}
#endif
virtual void Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) override;
+ gfxContext* aCtx) override;
NS_DISPLAY_DECL_NAME("MathMLBoundingMetrics", TYPE_MATHML_BOUNDING_METRICS)
private:
nsRect mRect;
};
void nsDisplayMathMLBoundingMetrics::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx)
+ gfxContext* aCtx)
{
DrawTarget* drawTarget = aCtx->GetDrawTarget();
Rect r = NSRectToRect(mRect + ToReferenceFrame(),
mFrame->PresContext()->AppUnitsPerDevPixel());
ColorPattern blue(ToDeviceColor(Color(0.f, 0.f, 1.f, 1.f)));
drawTarget->StrokeRect(r, blue);
}
@@ -334,24 +334,24 @@ public:
}
#ifdef NS_BUILD_REFCNT_LOGGING
virtual ~nsDisplayMathMLBar() {
MOZ_COUNT_DTOR(nsDisplayMathMLBar);
}
#endif
virtual void Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) override;
+ gfxContext* aCtx) override;
NS_DISPLAY_DECL_NAME("MathMLBar", TYPE_MATHML_BAR)
private:
nsRect mRect;
};
void nsDisplayMathMLBar::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx)
+ gfxContext* aCtx)
{
// paint the bar with the current text color
DrawTarget* drawTarget = aCtx->GetDrawTarget();
Rect rect =
NSRectToNonEmptySnappedRect(mRect + ToReferenceFrame(),
mFrame->PresContext()->AppUnitsPerDevPixel(),
*drawTarget);
ColorPattern color(ToDeviceColor(
--- a/layout/mathml/nsMathMLSelectedFrame.cpp
+++ b/layout/mathml/nsMathMLSelectedFrame.cpp
@@ -82,17 +82,17 @@ nsMathMLSelectedFrame::BuildDisplayList(
#if defined(DEBUG) && defined(SHOW_BOUNDING_BOX)
// visual debug
DisplayBoundingMetrics(aBuilder, this, mReference, mBoundingMetrics, aLists);
#endif
}
/* virtual */
LogicalSize
-nsMathMLSelectedFrame::ComputeSize(nsRenderingContext *aRenderingContext,
+nsMathMLSelectedFrame::ComputeSize(gfxContext *aRenderingContext,
WritingMode aWM,
const LogicalSize& aCBSize,
nscoord aAvailableISize,
const LogicalSize& aMargin,
const LogicalSize& aBorder,
const LogicalSize& aPadding,
ComputeSizeFlags aFlags)
{
--- a/layout/mathml/nsMathMLSelectedFrame.h
+++ b/layout/mathml/nsMathMLSelectedFrame.h
@@ -25,17 +25,17 @@ public:
const nsDisplayListSet& aLists) override;
virtual nsresult
Place(DrawTarget* aDrawTarget,
bool aPlaceOrigin,
ReflowOutput& aDesiredSize) override;
virtual mozilla::LogicalSize
- ComputeSize(nsRenderingContext *aRenderingContext,
+ ComputeSize(gfxContext *aRenderingContext,
mozilla::WritingMode aWritingMode,
const mozilla::LogicalSize& aCBSize,
nscoord aAvailableISize,
const mozilla::LogicalSize& aMargin,
const mozilla::LogicalSize& aBorder,
const mozilla::LogicalSize& aPadding,
ComputeSizeFlags aFlags) override;
--- a/layout/mathml/nsMathMLmencloseFrame.cpp
+++ b/layout/mathml/nsMathMLmencloseFrame.cpp
@@ -5,17 +5,16 @@
#include "nsMathMLmencloseFrame.h"
#include "gfx2DGlue.h"
#include "gfxUtils.h"
#include "mozilla/gfx/2D.h"
#include "mozilla/gfx/PathHelpers.h"
#include "nsPresContext.h"
-#include "nsRenderingContext.h"
#include "nsWhitespaceTokenizer.h"
#include "nsDisplayList.h"
#include "gfxContext.h"
#include "nsMathMLChar.h"
#include <algorithm>
using namespace mozilla;
@@ -754,27 +753,27 @@ public:
}
#ifdef NS_BUILD_REFCNT_LOGGING
virtual ~nsDisplayNotation() {
MOZ_COUNT_DTOR(nsDisplayNotation);
}
#endif
virtual void Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) override;
+ gfxContext* aCtx) override;
NS_DISPLAY_DECL_NAME("MathMLMencloseNotation", TYPE_MATHML_MENCLOSE_NOTATION)
private:
nsRect mRect;
nscoord mThickness;
nsMencloseNotation mType;
};
void nsDisplayNotation::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx)
+ gfxContext* aCtx)
{
DrawTarget& aDrawTarget = *aCtx->GetDrawTarget();
nsPresContext* presContext = mFrame->PresContext();
Float strokeWidth = presContext->AppUnitsToGfxUnits(mThickness);
Rect rect = NSRectToRect(mRect + ToReferenceFrame(),
presContext->AppUnitsPerDevPixel());
--- a/layout/mathml/nsMathMLmfencedFrame.cpp
+++ b/layout/mathml/nsMathMLmfencedFrame.cpp
@@ -1,16 +1,15 @@
/* -*- 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 "gfxContext.h"
#include "nsMathMLmfencedFrame.h"
-#include "nsRenderingContext.h"
#include "nsMathMLChar.h"
#include <algorithm>
using namespace mozilla;
//
// <mfenced> -- surround content with a pair of fences
//
@@ -599,17 +598,17 @@ GetMaxCharWidth(nsPresContext* aPr
width += leftSpace + rightSpace;
}
return width;
}
/* virtual */ void
-nsMathMLmfencedFrame::GetIntrinsicISizeMetrics(nsRenderingContext* aRenderingContext, ReflowOutput& aDesiredSize)
+nsMathMLmfencedFrame::GetIntrinsicISizeMetrics(gfxContext* aRenderingContext, ReflowOutput& aDesiredSize)
{
nscoord width = 0;
nsPresContext* presContext = PresContext();
const nsStyleFont* font = StyleFont();
float fontSizeInflation = nsLayoutUtils:: FontSizeInflationFor(this);
RefPtr<nsFontMetrics> fm =
nsLayoutUtils::GetFontMetricsForFrame(this, fontSizeInflation);
--- a/layout/mathml/nsMathMLmfencedFrame.h
+++ b/layout/mathml/nsMathMLmfencedFrame.h
@@ -40,17 +40,17 @@ public:
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus) override;
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) override;
virtual void
- GetIntrinsicISizeMetrics(nsRenderingContext* aRenderingContext,
+ GetIntrinsicISizeMetrics(gfxContext* aRenderingContext,
ReflowOutput& aDesiredSize) override;
virtual nsresult
AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType) override;
// override the base method because we must keep separators in sync
--- a/layout/mathml/nsMathMLmfracFrame.cpp
+++ b/layout/mathml/nsMathMLmfracFrame.cpp
@@ -6,17 +6,16 @@
#include "nsMathMLmfracFrame.h"
#include "gfxUtils.h"
#include "mozilla/gfx/2D.h"
#include "mozilla/RefPtr.h"
#include "nsLayoutUtils.h"
#include "nsPresContext.h"
-#include "nsRenderingContext.h"
#include "nsDisplayList.h"
#include "gfxContext.h"
#include "nsMathMLElement.h"
#include <algorithm>
#include "gfxMathTable.h"
using namespace mozilla;
using namespace mozilla::gfx;
@@ -604,27 +603,27 @@ public:
}
#ifdef NS_BUILD_REFCNT_LOGGING
virtual ~nsDisplayMathMLSlash() {
MOZ_COUNT_DTOR(nsDisplayMathMLSlash);
}
#endif
virtual void Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) override;
+ gfxContext* aCtx) override;
NS_DISPLAY_DECL_NAME("MathMLSlash", TYPE_MATHML_SLASH)
private:
nsRect mRect;
nscoord mThickness;
bool mRTL;
};
void nsDisplayMathMLSlash::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx)
+ gfxContext* aCtx)
{
DrawTarget& aDrawTarget = *aCtx->GetDrawTarget();
// get the gfxRect
nsPresContext* presContext = mFrame->PresContext();
Rect rect = NSRectToRect(mRect + ToReferenceFrame(),
presContext->AppUnitsPerDevPixel());
--- a/layout/mathml/nsMathMLmmultiscriptsFrame.cpp
+++ b/layout/mathml/nsMathMLmmultiscriptsFrame.cpp
@@ -1,18 +1,18 @@
/* -*- 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 "nsMathMLmmultiscriptsFrame.h"
#include "nsPresContext.h"
-#include "nsRenderingContext.h"
#include <algorithm>
+#include "gfxContext.h"
#include "gfxMathTable.h"
using mozilla::WritingMode;
//
// <mmultiscripts> -- attach prescripts and tensor indices to a base - implementation
// <msub> -- attach a subscript to a base - implementation
// <msubsup> -- attach a subscript-superscript pair to a base - implementation
--- a/layout/mathml/nsMathMLmoFrame.cpp
+++ b/layout/mathml/nsMathMLmoFrame.cpp
@@ -1,16 +1,16 @@
/* -*- 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 "gfxContext.h"
#include "nsMathMLmoFrame.h"
#include "nsPresContext.h"
-#include "nsRenderingContext.h"
#include "nsContentUtils.h"
#include "nsFrameSelection.h"
#include "nsMathMLElement.h"
#include <algorithm>
//
// <mo> -- operator, fence, or separator - implementation
//
@@ -1022,17 +1022,17 @@ nsMathMLmoFrame::MarkIntrinsicISizesDirt
// XXXldb This should really be marking dirty rather than rebuilding
// so that we don't rebuild multiple times for the same change.
RebuildAutomaticDataForChildren(target);
nsMathMLContainerFrame::MarkIntrinsicISizesDirty();
}
/* virtual */ void
-nsMathMLmoFrame::GetIntrinsicISizeMetrics(nsRenderingContext* aRenderingContext,
+nsMathMLmoFrame::GetIntrinsicISizeMetrics(gfxContext* aRenderingContext,
ReflowOutput& aDesiredSize)
{
ProcessOperatorData();
if (UseMathMLChar()) {
uint32_t stretchHint = GetStretchHint(mFlags, mPresentationData, true,
StyleFont());
aDesiredSize.Width() = mMathMLChar.
GetMaxWidth(PresContext(), aRenderingContext->GetDrawTarget(),
--- a/layout/mathml/nsMathMLmoFrame.h
+++ b/layout/mathml/nsMathMLmoFrame.h
@@ -51,17 +51,17 @@ public:
virtual nsresult
Place(DrawTarget* aDrawTarget,
bool aPlaceOrigin,
ReflowOutput& aDesiredSize) override;
virtual void MarkIntrinsicISizesDirty() override;
virtual void
- GetIntrinsicISizeMetrics(nsRenderingContext* aRenderingContext,
+ GetIntrinsicISizeMetrics(gfxContext* aRenderingContext,
ReflowOutput& aDesiredSize) override;
virtual nsresult
AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType) override;
// This method is called by the parent frame to ask <mo>
--- a/layout/mathml/nsMathMLmrootFrame.cpp
+++ b/layout/mathml/nsMathMLmrootFrame.cpp
@@ -1,17 +1,17 @@
/* -*- 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 "nsMathMLmrootFrame.h"
#include "nsPresContext.h"
-#include "nsRenderingContext.h"
#include <algorithm>
+#include "gfxContext.h"
#include "gfxMathTable.h"
using namespace mozilla;
//
// <mroot> -- form a radical - implementation
//
@@ -354,17 +354,17 @@ nsMathMLmrootFrame::Reflow(nsPresContext
mReference.x = 0;
mReference.y = aDesiredSize.BlockStartAscent();
aStatus.Reset();
NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
}
/* virtual */ void
-nsMathMLmrootFrame::GetIntrinsicISizeMetrics(nsRenderingContext* aRenderingContext, ReflowOutput& aDesiredSize)
+nsMathMLmrootFrame::GetIntrinsicISizeMetrics(gfxContext* aRenderingContext, ReflowOutput& aDesiredSize)
{
nsIFrame* baseFrame = mFrames.FirstChild();
nsIFrame* indexFrame = nullptr;
if (baseFrame)
indexFrame = baseFrame->GetNextSibling();
if (!indexFrame || indexFrame->GetNextSibling()) {
ReflowError(aRenderingContext->GetDrawTarget(), aDesiredSize);
return;
--- a/layout/mathml/nsMathMLmrootFrame.h
+++ b/layout/mathml/nsMathMLmrootFrame.h
@@ -42,17 +42,17 @@ public:
void
GetRadicalXOffsets(nscoord aIndexWidth, nscoord aSqrWidth,
nsFontMetrics* aFontMetrics,
nscoord* aIndexOffset,
nscoord* aSqrOffset);
virtual void
- GetIntrinsicISizeMetrics(nsRenderingContext* aRenderingContext,
+ GetIntrinsicISizeMetrics(gfxContext* aRenderingContext,
ReflowOutput& aDesiredSize) override;
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) override;
uint8_t
ScriptIncrement(nsIFrame* aFrame) override
--- a/layout/mathml/nsMathMLmtableFrame.cpp
+++ b/layout/mathml/nsMathMLmtableFrame.cpp
@@ -1,19 +1,19 @@
/* -*- 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 "gfxContext.h"
#include "nsMathMLmtableFrame.h"
#include "nsPresContext.h"
#include "nsStyleContext.h"
#include "nsStyleConsts.h"
#include "nsNameSpaceManager.h"
-#include "nsRenderingContext.h"
#include "nsCSSRendering.h"
#include "nsMathMLElement.h"
#include "nsTArray.h"
#include "nsTableFrame.h"
#include "celldata.h"
#include "mozilla/RestyleManager.h"
@@ -301,17 +301,17 @@ public:
nsMathMLmtdFrame* frame = static_cast<nsMathMLmtdFrame*>(mFrame);
ApplyBorderToStyle(frame, styleBorder);
nsRect bounds = CalculateBounds(styleBorder).GetBounds();
nsMargin overflow = ComputeBorderOverflow(frame, styleBorder);
bounds.Inflate(overflow);
return bounds;
}
- virtual void Paint(nsDisplayListBuilder* aBuilder, nsRenderingContext* aCtx) override
+ virtual void Paint(nsDisplayListBuilder* aBuilder, gfxContext* aCtx) override
{
nsStyleBorder styleBorder = *mFrame->StyleBorder();
nsMathMLmtdFrame* frame = static_cast<nsMathMLmtdFrame*>(mFrame);
ApplyBorderToStyle(frame, styleBorder);
nsRect bounds = nsRect(ToReferenceFrame(), mFrame->GetSize());
nsMargin overflow = ComputeBorderOverflow(frame, styleBorder);
bounds.Inflate(overflow);
--- a/layout/mathml/nsMathMLmunderoverFrame.cpp
+++ b/layout/mathml/nsMathMLmunderoverFrame.cpp
@@ -1,19 +1,19 @@
/* -*- 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 "nsMathMLmunderoverFrame.h"
#include "nsPresContext.h"
-#include "nsRenderingContext.h"
#include "nsMathMLmmultiscriptsFrame.h"
#include "nsMathMLElement.h"
#include <algorithm>
+#include "gfxContext.h"
#include "gfxMathTable.h"
//
// <munderover> -- attach an underscript-overscript pair to a base - implementation
// <mover> -- attach an overscript to a base - implementation
// <munder> -- attach an underscript to a base - implementation
//
--- a/layout/painting/FrameLayerBuilder.cpp
+++ b/layout/painting/FrameLayerBuilder.cpp
@@ -2,16 +2,17 @@
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "mozilla/DebugOnly.h"
#include "FrameLayerBuilder.h"
+#include "gfxContext.h"
#include "mozilla/LookAndFeel.h"
#include "mozilla/Maybe.h"
#include "mozilla/dom/ProfileTimelineMarkerBinding.h"
#include "mozilla/gfx/Matrix.h"
#include "ActiveLayerTracker.h"
#include "BasicLayers.h"
#include "ImageContainer.h"
#include "ImageLayers.h"
@@ -28,17 +29,16 @@
#include "nsAnimationManager.h"
#include "nsDisplayList.h"
#include "nsDocShell.h"
#include "nsIScrollableFrame.h"
#include "nsImageFrame.h"
#include "nsLayoutUtils.h"
#include "nsPresContext.h"
#include "nsPrintfCString.h"
-#include "nsRenderingContext.h"
#include "nsSVGIntegrationUtils.h"
#include "nsTransitionManager.h"
#include "mozilla/LayerTimelineMarker.h"
#include "mozilla/EffectCompositor.h"
#include "mozilla/Move.h"
#include "mozilla/ReverseIterator.h"
#include "mozilla/gfx/2D.h"
@@ -3659,17 +3659,17 @@ DumpPaintedImage(nsDisplayItem* aItem, S
}
#endif
static void
PaintInactiveLayer(nsDisplayListBuilder* aBuilder,
LayerManager* aManager,
nsDisplayItem* aItem,
gfxContext* aContext,
- nsRenderingContext* aCtx)
+ gfxContext* aCtx)
{
// This item has an inactive layer. Render it to a PaintedLayer
// using a temporary BasicLayerManager.
BasicLayerManager* basic = static_cast<BasicLayerManager*>(aManager);
RefPtr<gfxContext> context = aContext;
#ifdef MOZ_DUMP_PAINTING
int32_t appUnitsPerDevPixel = AppUnitsPerDevPixel(aItem);
nsIntRect itemVisibleRect =
@@ -5903,19 +5903,18 @@ static void DebugPaintItem(DrawTarget& a
SurfaceFormat::B8G8R8A8);
RefPtr<gfxContext> context = gfxContext::CreateOrNull(tempDT);
if (!context) {
// Leave this as crash, it's in the debugging code, we want to know
gfxDevCrash(LogReason::InvalidContext) << "DebugPaintItem context problem " << gfx::hexa(tempDT);
return;
}
context->SetMatrix(gfxMatrix::Translation(-bounds.x, -bounds.y));
- nsRenderingContext ctx(context);
-
- aItem->Paint(aBuilder, &ctx);
+
+ aItem->Paint(aBuilder, context);
RefPtr<SourceSurface> surface = tempDT->Snapshot();
DumpPaintedImage(aItem, surface);
aDrawTarget.DrawSurface(surface, bounds, Rect(Point(0,0), bounds.Size()));
aItem->SetPainted();
}
#endif
@@ -5972,17 +5971,17 @@ FrameLayerBuilder::RecomputeVisibilityFo
}
}
}
void
FrameLayerBuilder::PaintItems(nsTArray<ClippedDisplayItem>& aItems,
const nsIntRect& aRect,
gfxContext *aContext,
- nsRenderingContext *aRC,
+ gfxContext *aRC,
nsDisplayListBuilder* aBuilder,
nsPresContext* aPresContext,
const nsIntPoint& aOffset,
float aXScale, float aYScale,
int32_t aCommonClipCount)
{
DrawTarget& aDrawTarget = *aRC->GetDrawTarget();
@@ -6186,18 +6185,16 @@ FrameLayerBuilder::DrawPaintedLayer(Pain
// then we can skip this.
int32_t appUnitsPerDevPixel = presContext->AppUnitsPerDevPixel();
RecomputeVisibilityForItems(entry->mItems, builder, aDirtyRegion,
offset, appUnitsPerDevPixel,
userData->mXScale, userData->mYScale);
userData->mVisibilityComputedRegion = aDirtyRegion;
}
- nsRenderingContext rc(aContext);
-
if (shouldDrawRectsSeparately) {
for (auto iter = aRegionToDraw.RectIter(); !iter.Done(); iter.Next()) {
const nsIntRect& iterRect = iter.Get();
gfxContextAutoSaveRestore save(aContext);
aContext->NewPath();
aContext->Rectangle(ThebesRect(iterRect));
aContext->Clip();
@@ -6206,33 +6203,33 @@ FrameLayerBuilder::DrawPaintedLayer(Pain
// Apply the residual transform if it has been enabled, to ensure that
// snapping when we draw into aContext exactly matches the ideal transform.
// See above for why this is OK.
aContext->SetMatrix(
aContext->CurrentMatrix().Translate(aLayer->GetResidualTranslation() - gfxPoint(offset.x, offset.y)).
Scale(userData->mXScale, userData->mYScale));
- layerBuilder->PaintItems(entry->mItems, iterRect, aContext, &rc,
+ layerBuilder->PaintItems(entry->mItems, iterRect, aContext, aContext,
builder, presContext,
offset, userData->mXScale, userData->mYScale,
entry->mCommonClipCount);
if (gfxPrefs::GfxLoggingPaintedPixelCountEnabled()) {
aLayer->Manager()->AddPaintedPixelCount(iterRect.Area());
}
}
} else {
// Apply the residual transform if it has been enabled, to ensure that
// snapping when we draw into aContext exactly matches the ideal transform.
// See above for why this is OK.
aContext->SetMatrix(
aContext->CurrentMatrix().Translate(aLayer->GetResidualTranslation() - gfxPoint(offset.x, offset.y)).
Scale(userData->mXScale,userData->mYScale));
- layerBuilder->PaintItems(entry->mItems, aRegionToDraw.GetBounds(), aContext, &rc,
+ layerBuilder->PaintItems(entry->mItems, aRegionToDraw.GetBounds(), aContext, aContext,
builder, presContext,
offset, userData->mXScale, userData->mYScale,
entry->mCommonClipCount);
if (gfxPrefs::GfxLoggingPaintedPixelCountEnabled()) {
aLayer->Manager()->AddPaintedPixelCount(
aRegionToDraw.GetBounds().Area());
}
}
--- a/layout/painting/FrameLayerBuilder.h
+++ b/layout/painting/FrameLayerBuilder.h
@@ -672,17 +672,17 @@ protected:
const nsIntPoint& aOffset,
int32_t aAppUnitsPerDevPixel,
float aXScale,
float aYScale);
void PaintItems(nsTArray<ClippedDisplayItem>& aItems,
const nsIntRect& aRect,
gfxContext* aContext,
- nsRenderingContext* aRC,
+ gfxContext* aRC,
nsDisplayListBuilder* aBuilder,
nsPresContext* aPresContext,
const nsIntPoint& aOffset,
float aXScale, float aYScale,
int32_t aCommonClipCount);
/**
* We accumulate ClippedDisplayItem elements in a hashtable during
--- a/layout/painting/nsCSSRendering.cpp
+++ b/layout/painting/nsCSSRendering.cpp
@@ -4,16 +4,17 @@
* 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/. */
/* utility functions for drawing borders and backgrounds */
#include <ctime>
#include "gfx2DGlue.h"
+#include "gfxContext.h"
#include "mozilla/ArrayUtils.h"
#include "mozilla/DebugOnly.h"
#include "mozilla/gfx/2D.h"
#include "mozilla/gfx/Helpers.h"
#include "mozilla/gfx/PathHelpers.h"
#include "mozilla/HashFunctions.h"
#include "mozilla/MathAlgorithms.h"
@@ -36,18 +37,16 @@
#include "imgIContainer.h"
#include "ImageOps.h"
#include "nsCSSRendering.h"
#include "nsCSSColorUtils.h"
#include "nsITheme.h"
#include "nsThemeConstants.h"
#include "nsLayoutUtils.h"
#include "nsBlockFrame.h"
-#include "gfxContext.h"
-#include "nsRenderingContext.h"
#include "nsStyleStructInlines.h"
#include "nsCSSFrameConstructor.h"
#include "nsCSSProps.h"
#include "nsContentUtils.h"
#include "nsSVGEffects.h"
#include "nsSVGIntegrationUtils.h"
#include "gfxDrawable.h"
#include "GeckoProfiler.h"
@@ -624,17 +623,17 @@ nsCSSRendering::ComputePixelRadii(const
(*oBorderRadii)[C_BR] = Size(radii[eCornerBottomRightX],
radii[eCornerBottomRightY]);
(*oBorderRadii)[C_BL] = Size(radii[eCornerBottomLeftX],
radii[eCornerBottomLeftY]);
}
DrawResult
nsCSSRendering::PaintBorder(nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
nsIFrame* aForFrame,
const nsRect& aDirtyRect,
const nsRect& aBorderArea,
nsStyleContext* aStyleContext,
PaintBorderFlags aFlags,
Sides aSkipSides)
{
PROFILER_LABEL("nsCSSRendering", "PaintBorder",
@@ -790,17 +789,17 @@ ConstructBorderRenderer(nsPresContext* a
borderColors,
compositeColors,
bgColor);
}
DrawResult
nsCSSRendering::PaintBorderWithStyleBorder(nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
nsIFrame* aForFrame,
const nsRect& aDirtyRect,
const nsRect& aBorderArea,
const nsStyleBorder& aStyleBorder,
nsStyleContext* aStyleContext,
PaintBorderFlags aFlags,
Sides aSkipSides)
{
@@ -944,17 +943,17 @@ GetOutlineInnerRect(nsIFrame* aFrame)
if (savedOutlineInnerRect)
return *savedOutlineInnerRect;
NS_NOTREACHED("we should have saved a frame property");
return nsRect(nsPoint(0, 0), aFrame->GetSize());
}
Maybe<nsCSSBorderRenderer>
nsCSSRendering::CreateBorderRendererForOutline(nsPresContext* aPresContext,
- nsRenderingContext* aRenderingContext,
+ gfxContext* aRenderingContext,
nsIFrame* aForFrame,
const nsRect& aDirtyRect,
const nsRect& aBorderArea,
nsStyleContext* aStyleContext)
{
nscoord twipsRadii[8];
// Get our style context's color struct.
@@ -1071,17 +1070,17 @@ nsCSSRendering::CreateBorderRendererForO
nullptr,
bgColor);
return Some(br);
}
void
nsCSSRendering::PaintOutline(nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
nsIFrame* aForFrame,
const nsRect& aDirtyRect,
const nsRect& aBorderArea,
nsStyleContext* aStyleContext)
{
Maybe<nsCSSBorderRenderer> br = CreateBorderRendererForOutline(aPresContext,
&aRenderingContext,
aForFrame,
@@ -1454,17 +1453,17 @@ nsCSSRendering::GetBorderRadii(const nsR
ComputePixelRadii(twipsRadii, twipsPerPixel, &aOutRadii);
}
return hasBorderRadius;
}
void
nsCSSRendering::PaintBoxShadowOuter(nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
nsIFrame* aForFrame,
const nsRect& aFrameArea,
const nsRect& aDirtyRect,
float aOpacity)
{
DrawTarget& aDrawTarget = *aRenderingContext.GetDrawTarget();
nsCSSShadowArray* shadows = aForFrame->StyleEffects()->mBoxShadow;
if (!shadows)
@@ -1509,17 +1508,16 @@ nsCSSRendering::PaintBoxShadowOuter(nsPr
aForFrame->GetPaddingRect() - aForFrame->GetPosition() + aFrameArea.TopLeft();
skipGfxRect = nsLayoutUtils::RectToGfxRect(paddingRect, twipsPerPixel);
} else if (hasBorderRadius) {
skipGfxRect.Deflate(gfxMargin(
std::max(borderRadii[C_TL].height, borderRadii[C_TR].height), 0,
std::max(borderRadii[C_BL].height, borderRadii[C_BR].height), 0));
}
- gfxContext* renderContext = aRenderingContext.ThebesContext();
for (uint32_t i = shadows->Length(); i > 0; --i) {
nsCSSShadowItem* shadowItem = shadows->ShadowAt(i - 1);
if (shadowItem->mInset)
continue;
nsRect shadowRect = frameRect;
shadowRect.MoveBy(shadowItem->mXOffset, shadowItem->mYOffset);
@@ -1542,34 +1540,34 @@ nsCSSRendering::PaintBoxShadowOuter(nsPr
Color gfxShadowColor = GetShadowColor(shadowItem, aForFrame, aOpacity);
if (nativeTheme) {
nsContextBoxBlur blurringArea;
// When getting the widget shape from the native theme, we're going
// to draw the widget into the shadow surface to create a mask.
// We need to ensure that there actually *is* a shadow surface
- // and that we're not going to draw directly into renderContext.
+ // and that we're not going to draw directly into aRenderingContext.
gfxContext* shadowContext =
- blurringArea.Init(shadowRect, shadowItem->mSpread,
- blurRadius, twipsPerPixel, renderContext, aDirtyRect,
+ blurringArea.Init(shadowRect, shadowItem->mSpread, blurRadius,
+ twipsPerPixel, &aRenderingContext, aDirtyRect,
useSkipGfxRect ? &skipGfxRect : nullptr,
nsContextBoxBlur::FORCE_MASK);
if (!shadowContext)
continue;
MOZ_ASSERT(shadowContext == blurringArea.GetContext());
- renderContext->Save();
- renderContext->SetColor(gfxShadowColor);
+ aRenderingContext.Save();
+ aRenderingContext.SetColor(gfxShadowColor);
// Draw the shape of the frame so it can be blurred. Recall how nsContextBoxBlur
// doesn't make any temporary surfaces if blur is 0 and it just returns the original
// surface? If we have no blur, we're painting this fill on the actual content surface
- // (renderContext == shadowContext) which is why we set up the color and clip
+ // (aRenderingContext == shadowContext) which is why we set up the color and clip
// before doing this.
// We don't clip the border-box from the shadow, nor any other box.
// We assume that the native theme is going to paint over the shadow.
// Draw the widget shape
gfxContextMatrixAutoSaveRestore save(shadowContext);
gfxPoint devPixelOffset =
@@ -1577,24 +1575,23 @@ nsCSSRendering::PaintBoxShadowOuter(nsPr
shadowItem->mYOffset),
aPresContext->AppUnitsPerDevPixel());
shadowContext->SetMatrix(
shadowContext->CurrentMatrix().Translate(devPixelOffset));
nsRect nativeRect = aDirtyRect;
nativeRect.MoveBy(-nsPoint(shadowItem->mXOffset, shadowItem->mYOffset));
nativeRect.IntersectRect(frameRect, nativeRect);
- nsRenderingContext wrapperCtx(shadowContext);
- aPresContext->GetTheme()->DrawWidgetBackground(&wrapperCtx, aForFrame,
+ aPresContext->GetTheme()->DrawWidgetBackground(shadowContext, aForFrame,
styleDisplay->mAppearance, aFrameArea, nativeRect);
blurringArea.DoPaint();
- renderContext->Restore();
+ aRenderingContext.Restore();
} else {
- renderContext->Save();
+ aRenderingContext.Save();
{
Rect innerClipRect = NSRectToRect(frameRect, twipsPerPixel);
if (!MaybeSnapToDevicePixels(innerClipRect, aDrawTarget, true)) {
innerClipRect.Round();
}
// Clip out the interior of the frame's border edge so that the shadow
@@ -1603,17 +1600,17 @@ nsCSSRendering::PaintBoxShadowOuter(nsPr
aDrawTarget.CreatePathBuilder(FillRule::FILL_EVEN_ODD);
AppendRectToPath(builder, shadowGfxRectPlusBlur);
if (hasBorderRadius) {
AppendRoundedRectToPath(builder, innerClipRect, borderRadii);
} else {
AppendRectToPath(builder, innerClipRect);
}
RefPtr<Path> path = builder->Finish();
- renderContext->Clip(path);
+ aRenderingContext.Clip(path);
}
// Clip the shadow so that we only get the part that applies to aForFrame.
nsRect fragmentClip = shadowRectPlusBlur;
Sides skipSides = aForFrame->GetSkipSides();
if (!skipSides.IsEmpty()) {
if (skipSides.Left()) {
nscoord xmost = fragmentClip.XMost();
@@ -1636,17 +1633,17 @@ nsCSSRendering::PaintBoxShadowOuter(nsPr
nscoord ymost = fragmentClip.YMost();
nscoord overflow = ymost - aFrameArea.YMost();
if (overflow > 0) {
fragmentClip.height -= overflow;
}
}
}
fragmentClip = fragmentClip.Intersect(aDirtyRect);
- renderContext->
+ aRenderingContext.
Clip(NSRectToSnappedRect(fragmentClip,
aForFrame->PresContext()->AppUnitsPerDevPixel(),
aDrawTarget));
RectCornerRadii clipRectRadii;
if (hasBorderRadius) {
Float spreadDistance = shadowItem->mSpread / twipsPerPixel;
@@ -1656,25 +1653,25 @@ nsCSSRendering::PaintBoxShadowOuter(nsPr
borderSizes[eSideTop] = spreadDistance;
borderSizes[eSideRight] = spreadDistance;
borderSizes[eSideBottom] = spreadDistance;
nsCSSBorderRenderer::ComputeOuterRadii(borderRadii, borderSizes,
&clipRectRadii);
}
- nsContextBoxBlur::BlurRectangle(renderContext,
+ nsContextBoxBlur::BlurRectangle(&aRenderingContext,
shadowRect,
twipsPerPixel,
hasBorderRadius ? &clipRectRadii : nullptr,
blurRadius,
gfxShadowColor,
aDirtyRect,
skipGfxRect);
- renderContext->Restore();
+ aRenderingContext.Restore();
}
}
}
nsRect
nsCSSRendering::GetBoxShadowInnerPaddingRect(nsIFrame* aFrame,
const nsRect& aFrameArea)
@@ -1740,17 +1737,17 @@ nsCSSRendering::GetShadowInnerRadii(nsIF
&aOutInnerRadii);
}
return hasBorderRadius;
}
void
nsCSSRendering::PaintBoxShadowInner(nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
nsIFrame* aForFrame,
const nsRect& aFrameArea)
{
if (!ShouldPaintBoxShadowInner(aForFrame)) {
return;
}
nsCSSShadowArray* shadows = aForFrame->StyleEffects()->mBoxShadow;
@@ -1831,50 +1828,49 @@ nsCSSRendering::PaintBoxShadowInner(nsPr
std::max(clipRectRadii[C_TL].height, clipRectRadii[C_TR].height), 0,
std::max(clipRectRadii[C_BL].height, clipRectRadii[C_BR].height), 0));
}
// When there's a blur radius, gfxAlphaBoxBlur leaves the skiprect area
// unchanged. And by construction the gfxSkipRect is not touched by the
// rendered shadow (even after blurring), so those pixels must be completely
// transparent in the shadow, so drawing them changes nothing.
- gfxContext* renderContext = aRenderingContext.ThebesContext();
- DrawTarget* drawTarget = renderContext->GetDrawTarget();
+ DrawTarget* drawTarget = aRenderingContext.GetDrawTarget();
// Clip the context to the area of the frame's padding rect, so no part of the
// shadow is painted outside. Also cut out anything beyond where the inset shadow
// will be.
Rect shadowGfxRect = NSRectToRect(paddingRect, twipsPerPixel);
shadowGfxRect.Round();
Color shadowColor = GetShadowColor(shadowItem, aForFrame, 1.0);
- renderContext->Save();
+ aRenderingContext.Save();
// This clips the outside border radius.
// clipRectRadii is the border radius inside the inset shadow.
if (hasBorderRadius) {
RefPtr<Path> roundedRect =
MakePathForRoundedRect(*drawTarget, shadowGfxRect, innerRadii);
- renderContext->Clip(roundedRect);
+ aRenderingContext.Clip(roundedRect);
} else {
- renderContext->Clip(shadowGfxRect);
+ aRenderingContext.Clip(shadowGfxRect);
}
nsContextBoxBlur insetBoxBlur;
gfxRect destRect = nsLayoutUtils::RectToGfxRect(shadowPaintRect, twipsPerPixel);
Point shadowOffset(shadowItem->mXOffset / twipsPerPixel,
shadowItem->mYOffset / twipsPerPixel);
- insetBoxBlur.InsetBoxBlur(renderContext, ToRect(destRect),
+ insetBoxBlur.InsetBoxBlur(&aRenderingContext, ToRect(destRect),
shadowClipGfxRect, shadowColor,
blurRadius, spreadDistanceAppUnits,
twipsPerPixel, hasBorderRadius,
clipRectRadii, ToRect(skipGfxRect),
shadowOffset);
- renderContext->Restore();
+ aRenderingContext.Restore();
}
}
/* static */
nsCSSRendering::PaintBGParams
nsCSSRendering::PaintBGParams::ForAllLayers(nsPresContext& aPresCtx,
const nsRect& aDirtyRect,
const nsRect& aBorderArea,
@@ -1908,17 +1904,17 @@ nsCSSRendering::PaintBGParams::ForSingle
aFrame, aPaintFlags, aLayer, aCompositionOp,
aOpacity);
return result;
}
DrawResult
nsCSSRendering::PaintStyleImageLayer(const PaintBGParams& aParams,
- nsRenderingContext& aRenderingCtx)
+ gfxContext& aRenderingCtx)
{
PROFILER_LABEL("nsCSSRendering", "PaintBackground",
js::ProfileEntry::Category::GRAPHICS);
NS_PRECONDITION(aParams.frame,
"Frame is expected to be provided to PaintBackground");
nsStyleContext *sc;
@@ -2501,17 +2497,17 @@ DetermineCompositionOp(const nsCSSRender
return nsCSSRendering::GetGFXCompositeMode(layer.mComposite);
}
return nsCSSRendering::GetGFXBlendMode(layer.mBlendMode);
}
DrawResult
nsCSSRendering::PaintStyleImageLayerWithSC(const PaintBGParams& aParams,
- nsRenderingContext& aRenderingCtx,
+ gfxContext& aRenderingCtx,
nsStyleContext *aBackgroundSC,
const nsStyleBorder& aBorder)
{
NS_PRECONDITION(aParams.frame,
"Frame is expected to be provided to PaintBackground");
// If we're drawing all layers, aCompositonOp is ignored, so make sure that
// it was left at its default value.
@@ -2576,17 +2572,16 @@ nsCSSRendering::PaintStyleImageLayerWith
return DrawResult::SUCCESS;
// The 'bgClipArea' (used only by the image tiling logic, far below)
// is the caller-provided aParams.bgClipRect if any, or else the area
// determined by the value of 'background-clip' in
// SetupCurrentBackgroundClip. (Arguably it should be the
// intersection, but that breaks the table painter -- in particular,
// taking the intersection breaks reftests/bugs/403249-1[ab].)
- gfxContext* ctx = aRenderingCtx.ThebesContext();
nscoord appUnitsPerPixel = aParams.presCtx.AppUnitsPerDevPixel();
ImageLayerClipState clipState;
if (aParams.bgClipRect) {
clipState.mBGClipArea = *aParams.bgClipRect;
clipState.mCustomClip = true;
clipState.mHasRoundedCorners = false;
SetupDirtyRects(clipState.mBGClipArea, aParams.dirtyRect, appUnitsPerPixel,
&clipState.mDirtyRectInAppUnits,
@@ -2597,25 +2592,25 @@ nsCSSRendering::PaintStyleImageLayerWith
aParams.dirtyRect,
(aParams.paintFlags & PAINTBG_WILL_PAINT_BORDER),
appUnitsPerPixel,
&clipState);
}
// If we might be using a background color, go ahead and set it now.
if (drawBackgroundColor && !isCanvasFrame) {
- ctx->SetColor(Color::FromABGR(bgColor));
+ aRenderingCtx.SetColor(Color::FromABGR(bgColor));
}
// If there is no background image, draw a color. (If there is
// neither a background image nor a color, we wouldn't have gotten
// this far.)
if (!drawBackgroundImage) {
if (!isCanvasFrame) {
- DrawBackgroundColor(clipState, ctx, appUnitsPerPixel);
+ DrawBackgroundColor(clipState, &aRenderingCtx, appUnitsPerPixel);
}
return DrawResult::SUCCESS;
}
if (layers.mImageCount < 1) {
// Return if there are no background layers, all work from this point
// onwards happens iteratively on these.
return DrawResult::SUCCESS;
@@ -2637,17 +2632,17 @@ nsCSSRendering::PaintStyleImageLayerWith
aParams.frame->AssociateImage(layers.mLayers[i].mImage,
&aParams.presCtx);
}
}
// The background color is rendered over the entire dirty area,
// even if the image isn't.
if (drawBackgroundColor && !isCanvasFrame) {
- DrawBackgroundColor(clipState, ctx, appUnitsPerPixel);
+ DrawBackgroundColor(clipState, &aRenderingCtx, appUnitsPerPixel);
}
if (!drawBackgroundImage) {
return DrawResult::SUCCESS; // No need to draw layer image, we can early
// return now.
}
// Compute the outermost boundary of the area that might be painted.
@@ -2681,27 +2676,28 @@ nsCSSRendering::PaintStyleImageLayerWith
// For the bottom layer, we already called GetImageLayerClip above
// and it stored its results in clipState.
if (!isBottomLayer) {
GetImageLayerClip(layer, aParams.frame,
aBorder, aParams.borderArea, aParams.dirtyRect,
(aParams.paintFlags & PAINTBG_WILL_PAINT_BORDER),
appUnitsPerPixel, &clipState);
}
- SetupImageLayerClip(clipState, ctx, appUnitsPerPixel, &autoSR);
+ SetupImageLayerClip(clipState, &aRenderingCtx,
+ appUnitsPerPixel, &autoSR);
if (!clipBorderArea.IsEqualEdges(aParams.borderArea)) {
// We're drawing the background for the joined continuation boxes
// so we need to clip that to the slice that we want for this
// frame.
gfxRect clip =
nsLayoutUtils::RectToGfxRect(aParams.borderArea, appUnitsPerPixel);
- autoSR.EnsureSaved(ctx);
- ctx->NewPath();
- ctx->SnappedRectangle(clip);
- ctx->Clip();
+ autoSR.EnsureSaved(&aRenderingCtx);
+ aRenderingCtx.NewPath();
+ aRenderingCtx.SnappedRectangle(clip);
+ aRenderingCtx.Clip();
}
}
}
// Skip the following layer preparing and painting code if the current
// layer is not selected for drawing.
if (aParams.layer >= 0 && i != (uint32_t)aParams.layer) {
continue;
@@ -2715,32 +2711,32 @@ nsCSSRendering::PaintStyleImageLayerWith
// Skip the layer painting code if we found the dirty region is empty.
if (clipState.mDirtyRectInDevPx.IsEmpty()) {
continue;
}
if (!state.mFillArea.IsEmpty()) {
CompositionOp co = DetermineCompositionOp(aParams, layers, i);
if (co != CompositionOp::OP_OVER) {
- NS_ASSERTION(ctx->CurrentOp() == CompositionOp::OP_OVER,
+ NS_ASSERTION(aRenderingCtx.CurrentOp() == CompositionOp::OP_OVER,
"It is assumed the initial op is OP_OVER, when it is "
"restored later");
- ctx->SetOp(co);
+ aRenderingCtx.SetOp(co);
}
result &=
state.mImageRenderer.DrawLayer(&aParams.presCtx,
aRenderingCtx,
state.mDestArea, state.mFillArea,
state.mAnchor + paintBorderArea.TopLeft(),
clipState.mDirtyRectInAppUnits,
state.mRepeatSize, aParams.opacity);
if (co != CompositionOp::OP_OVER) {
- ctx->SetOp(CompositionOp::OP_OVER);
+ aRenderingCtx.SetOp(CompositionOp::OP_OVER);
}
}
}
return result;
}
DrawResult
--- a/layout/painting/nsCSSRendering.h
+++ b/layout/painting/nsCSSRendering.h
@@ -15,19 +15,19 @@
#include "mozilla/gfx/Rect.h"
#include "mozilla/TypedEnumBits.h"
#include "nsLayoutUtils.h"
#include "nsStyleStruct.h"
#include "nsIFrame.h"
#include "nsImageRenderer.h"
#include "nsCSSRenderingBorders.h"
+class gfxContext;
class nsStyleContext;
class nsPresContext;
-class nsRenderingContext;
namespace mozilla {
namespace gfx {
struct Color;
class DrawTarget;
} // namespace gfx
@@ -122,17 +122,17 @@ struct nsCSSRendering {
static bool GetShadowInnerRadii(nsIFrame* aFrame,
const nsRect& aFrameArea,
RectCornerRadii& aOutInnerRadii);
static nsRect GetBoxShadowInnerPaddingRect(nsIFrame* aFrame,
const nsRect& aFrameArea);
static bool ShouldPaintBoxShadowInner(nsIFrame* aFrame);
static void PaintBoxShadowInner(nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
nsIFrame* aForFrame,
const nsRect& aFrameArea);
static bool GetBorderRadii(const nsRect& aFrameRect,
const nsRect& aBorderRect,
nsIFrame* aFrame,
RectCornerRadii& aOutRadii);
static nsRect GetShadowRect(const nsRect aFrameArea,
@@ -142,47 +142,47 @@ struct nsCSSRendering {
nsIFrame* aFrame,
float aOpacity);
// Returns if the frame has a themed frame.
// aMaybeHasBorderRadius will return false if we can early detect
// that we don't have a border radius.
static bool HasBoxShadowNativeTheme(nsIFrame* aFrame,
bool& aMaybeHasBorderRadius);
static void PaintBoxShadowOuter(nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
nsIFrame* aForFrame,
const nsRect& aFrameArea,
const nsRect& aDirtyRect,
float aOpacity = 1.0);
static void ComputePixelRadii(const nscoord *aAppUnitsRadii,
nscoord aAppUnitsPerPixel,
RectCornerRadii *oBorderRadii);
/**
* Render the border for an element using css rendering rules
* for borders. aSkipSides says which sides to skip
* when rendering, the default is to skip none.
*/
static DrawResult PaintBorder(nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
nsIFrame* aForFrame,
const nsRect& aDirtyRect,
const nsRect& aBorderArea,
nsStyleContext* aStyleContext,
mozilla::PaintBorderFlags aFlags,
Sides aSkipSides = Sides());
/**
* Like PaintBorder, but taking an nsStyleBorder argument instead of
* getting it from aStyleContext. aSkipSides says which sides to skip
* when rendering, the default is to skip none.
*/
static DrawResult PaintBorderWithStyleBorder(nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
nsIFrame* aForFrame,
const nsRect& aDirtyRect,
const nsRect& aBorderArea,
const nsStyleBorder& aBorderStyle,
nsStyleContext* aStyleContext,
mozilla::PaintBorderFlags aFlags,
Sides aSkipSides = Sides());
@@ -202,28 +202,28 @@ struct nsCSSRendering {
const nsRect& aDirtyRect,
const nsRect& aBorderArea,
const nsStyleBorder& aBorderStyle,
nsStyleContext* aStyleContext,
Sides aSkipSides = Sides());
static mozilla::Maybe<nsCSSBorderRenderer>
CreateBorderRendererForOutline(nsPresContext* aPresContext,
- nsRenderingContext* aRenderingContext,
+ gfxContext* aRenderingContext,
nsIFrame* aForFrame,
const nsRect& aDirtyRect,
const nsRect& aBorderArea,
nsStyleContext* aStyleContext);
/**
* Render the outline for an element using css rendering rules
* for borders.
*/
static void PaintOutline(nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
nsIFrame* aForFrame,
const nsRect& aDirtyRect,
const nsRect& aBorderArea,
nsStyleContext* aStyleContext);
/**
* Render keyboard focus on an element.
* |aFocusRect| is the outer rectangle of the focused element.
@@ -469,33 +469,33 @@ struct nsCSSRendering {
frame(aFrame),
paintFlags(aPaintFlags),
layer(aLayer),
compositionOp(aCompositionOp),
opacity(aOpacity) {}
};
static DrawResult PaintStyleImageLayer(const PaintBGParams& aParams,
- nsRenderingContext& aRenderingCtx);
+ gfxContext& aRenderingCtx);
/**
* Same as |PaintStyleImageLayer|, except using the provided style structs.
* This short-circuits the code that ensures that the root element's
* {background|mask} is drawn on the canvas.
* The aLayer parameter allows you to paint a single layer of the
* {background|mask}.
* The default value for aLayer, -1, means that all layers will be painted.
* The background color will only be painted if the back-most layer is also
* being painted and (aParams.paintFlags & PAINTBG_MASK_IMAGE) is false.
* aCompositionOp is only respected if a single layer is specified (aLayer != -1).
* If all layers are painted, the image layer's blend mode (or the mask
* layer's composition mode) will be used.
*/
static DrawResult PaintStyleImageLayerWithSC(const PaintBGParams& aParams,
- nsRenderingContext& aRenderingCtx,
+ gfxContext& aRenderingCtx,
nsStyleContext *mBackgroundSC,
const nsStyleBorder& aBorder);
static bool CanBuildWebRenderDisplayItemsForStyleImageLayer(LayerManager* aManager,
nsPresContext& aPresCtx,
nsIFrame *aFrame,
const nsStyleBackground* aBackgroundStyle,
int32_t aLayer);
--- a/layout/painting/nsCSSRenderingBorders.cpp
+++ b/layout/painting/nsCSSRenderingBorders.cpp
@@ -3608,30 +3608,29 @@ nsCSSBorderImageRenderer::CreateBorderIm
nsCSSBorderImageRenderer renderer(aForFrame, aBorderArea,
aStyleBorder, aSkipSides, imgRenderer);
*aDrawResult = DrawResult::SUCCESS;
return Some(renderer);
}
DrawResult
nsCSSBorderImageRenderer::DrawBorderImage(nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
nsIFrame* aForFrame,
const nsRect& aDirtyRect)
{
// NOTE: no Save() yet, we do that later by calling autoSR.EnsureSaved()
// in case we need it.
gfxContextAutoSaveRestore autoSR;
if (!mClip.IsEmpty()) {
- autoSR.EnsureSaved(aRenderingContext.ThebesContext());
- aRenderingContext.ThebesContext()->
- Clip(NSRectToSnappedRect(mClip,
- aForFrame->PresContext()->AppUnitsPerDevPixel(),
- *aRenderingContext.GetDrawTarget()));
+ autoSR.EnsureSaved(&aRenderingContext);
+ aRenderingContext.Clip(NSRectToSnappedRect(mClip,
+ aForFrame->PresContext()->AppUnitsPerDevPixel(),
+ *aRenderingContext.GetDrawTarget()));
}
// intrinsicSize.CanComputeConcreteSize() return false means we can not
// read intrinsic size from aStyleBorder.mBorderImageSource.
// In this condition, we pass imageSize(a resolved size comes from
// default sizing algorithm) to renderer as the viewport size.
CSSSizeOrRatio intrinsicSize = mImageRenderer.ComputeIntrinsicSize();
Maybe<nsSize> svgViewportSize = intrinsicSize.CanComputeConcreteSize() ?
--- a/layout/painting/nsCSSRenderingBorders.h
+++ b/layout/painting/nsCSSRenderingBorders.h
@@ -291,17 +291,17 @@ public:
const nsStyleBorder& aStyleBorder,
const nsRect& aDirtyRect,
nsIFrame::Sides aSkipSides,
uint32_t aFlags,
mozilla::image::DrawResult* aDrawResult);
mozilla::image::DrawResult
DrawBorderImage(nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
nsIFrame* aForFrame,
const nsRect& aDirtyRect);
nsCSSBorderImageRenderer(const nsCSSBorderImageRenderer& aRhs);
nsCSSBorderImageRenderer& operator=(const nsCSSBorderImageRenderer& aRhs);
private:
nsCSSBorderImageRenderer(nsIFrame* aForFrame,
--- a/layout/painting/nsCSSRenderingGradients.cpp
+++ b/layout/painting/nsCSSRenderingGradients.cpp
@@ -17,17 +17,16 @@
#include "nsStyleConsts.h"
#include "nsPresContext.h"
#include "nsPoint.h"
#include "nsRect.h"
#include "nsStyleContext.h"
#include "nsCSSColorUtils.h"
#include "gfxContext.h"
-#include "nsRenderingContext.h"
#include "nsStyleStructInlines.h"
#include "nsCSSProps.h"
#include "mozilla/Telemetry.h"
#include "gfxUtils.h"
#include "gfxGradientCache.h"
#include "mozilla/layers/StackingContextHelper.h"
#include "mozilla/layers/WebRenderLayerManager.h"
--- a/layout/painting/nsDisplayList.cpp
+++ b/layout/painting/nsDisplayList.cpp
@@ -11,23 +11,23 @@
*/
#include "nsDisplayList.h"
#include <stdint.h>
#include <algorithm>
#include <limits>
+#include "gfxContext.h"
#include "gfxUtils.h"
#include "mozilla/dom/TabChild.h"
#include "mozilla/dom/KeyframeEffectReadOnly.h"
#include "mozilla/gfx/2D.h"
#include "mozilla/layers/PLayerTransaction.h"
#include "nsCSSRendering.h"
-#include "nsRenderingContext.h"
#include "nsISelectionController.h"
#include "nsIPresShell.h"
#include "nsRegion.h"
#include "nsStyleStructInlines.h"
#include "nsStyleTransformMatrix.h"
#include "gfxMatrix.h"
#include "gfxPrefs.h"
#include "nsSVGIntegrationUtils.h"
@@ -665,17 +665,17 @@ AddAnimationsForProperty(nsIFrame* aFram
if (sentAnimations && aProperty == eCSSProperty_transform) {
TimeStamp now = aFrame->PresContext()->RefreshDriver()->MostRecentRefresh();
effects->UpdateLastTransformSyncTime(now);
}
}
static bool
-GenerateAndPushTextMask(nsIFrame* aFrame, nsRenderingContext* aContext,
+GenerateAndPushTextMask(nsIFrame* aFrame, gfxContext* aContext,
const nsRect& aFillRect, nsDisplayListBuilder* aBuilder)
{
if (aBuilder->IsForGenerateGlyphMask() ||
aBuilder->IsForPaintingSelectionBG()) {
return false;
}
// The main function of enabling background-clip:text property value.
@@ -684,17 +684,17 @@ GenerateAndPushTextMask(nsIFrame* aFrame
// 1. Paint background color of the selection text if any.
// 2. Generate a mask by all descendant text frames
// 3. Push the generated mask into aContext.
//
// TBD: we actually generate display list of aFrame twice here. It's better
// to reuse the same display list and paint that one twice, one for selection
// background, one for generating text mask.
- gfxContext* sourceCtx = aContext->ThebesContext();
+ gfxContext* sourceCtx = aContext;
gfxRect bounds =
nsLayoutUtils::RectToGfxRect(aFillRect,
aFrame->PresContext()->AppUnitsPerDevPixel());
{
// Paint text selection background into sourceCtx.
gfxContextMatrixAutoSaveRestore save(sourceCtx);
sourceCtx->SetMatrix(sourceCtx->CurrentMatrix().Translate(bounds.TopLeft()));
@@ -726,18 +726,17 @@ GenerateAndPushTextMask(nsIFrame* aFrame
RefPtr<gfxContext> maskCtx = gfxContext::CreatePreservingTransformOrNull(maskDT);
MOZ_ASSERT(maskCtx);
gfxMatrix currentMatrix = sourceCtx->CurrentMatrix();
maskCtx->SetMatrix(gfxMatrix::Translation(bounds.TopLeft()) *
currentMatrix *
gfxMatrix::Translation(-drawRect.TopLeft()));
// Shade text shape into mask A8 surface.
- nsRenderingContext rc(maskCtx);
- nsLayoutUtils::PaintFrame(&rc, aFrame,
+ nsLayoutUtils::PaintFrame(maskCtx, aFrame,
nsRect(nsPoint(0, 0), aFrame->GetSize()),
NS_RGB(255, 255, 255),
nsDisplayListBuilderMode::GENERATE_GLYPH);
// Push the generated mask into aContext, so that the caller can pop and
// blend with it.
Matrix maskTransform = ToMatrix(currentMatrix) *
Matrix::Translation(-drawRect.x, -drawRect.y);
@@ -2057,17 +2056,17 @@ nsDisplayListBuilder::GetWidgetLayerMana
}
/**
* We paint by executing a layer manager transaction, constructing a
* single layer representing the display list, and then making it the
* root of the layer manager, drawing into the PaintedLayers.
*/
already_AddRefed<LayerManager> nsDisplayList::PaintRoot(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx,
+ gfxContext* aCtx,
uint32_t aFlags) {
PROFILER_LABEL("nsDisplayList", "PaintRoot",
js::ProfileEntry::Category::GRAPHICS);
RefPtr<LayerManager> layerManager;
bool widgetTransaction = false;
bool doBeginTransaction = true;
nsView *view = nullptr;
@@ -2107,17 +2106,17 @@ already_AddRefed<LayerManager> nsDisplay
layerBuilder->SetLayerTreeCompressionMode();
}
{
GeckoProfilerTracingRAII tracer("Paint", "LayerBuilding");
if (doBeginTransaction) {
if (aCtx) {
- if (!layerManager->BeginTransactionWithTarget(aCtx->ThebesContext())) {
+ if (!layerManager->BeginTransactionWithTarget(aCtx)) {
return nullptr;
}
} else {
if (!layerManager->BeginTransaction()) {
return nullptr;
}
}
}
@@ -2838,17 +2837,17 @@ nsDisplaySolidColor::BuildLayer(nsDispla
layer->SetBaseTransform(gfx::Matrix4x4::Translation(aContainerParameters.mOffset.x,
aContainerParameters.mOffset.y, 0));
return layer.forget();
}
void
nsDisplaySolidColor::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx)
+ gfxContext* aCtx)
{
int32_t appUnitsPerDevPixel = mFrame->PresContext()->AppUnitsPerDevPixel();
DrawTarget* drawTarget = aCtx->GetDrawTarget();
Rect rect =
NSRectToSnappedRect(mVisibleRect, appUnitsPerDevPixel, *drawTarget);
drawTarget->FillRect(rect, ColorPattern(ToDeviceColor(mColor)));
}
@@ -2866,17 +2865,17 @@ nsRect
nsDisplaySolidColorRegion::GetBounds(nsDisplayListBuilder* aBuilder, bool* aSnap)
{
*aSnap = true;
return mRegion.GetBounds();
}
void
nsDisplaySolidColorRegion::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx)
+ gfxContext* aCtx)
{
int32_t appUnitsPerDevPixel = mFrame->PresContext()->AppUnitsPerDevPixel();
DrawTarget* drawTarget = aCtx->GetDrawTarget();
ColorPattern color(mColor);
for (auto iter = mRegion.RectIter(); !iter.Done(); iter.Next()) {
Rect rect =
NSRectToSnappedRect(iter.Get(), appUnitsPerDevPixel, *drawTarget);
drawTarget->FillRect(rect, color);
@@ -3654,25 +3653,25 @@ nsDisplayBackgroundImage::RenderingMight
if (layer.RenderingMightDependOnPositioningAreaSizeChange()) {
return true;
}
return false;
}
void
nsDisplayBackgroundImage::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) {
+ gfxContext* aCtx) {
PaintInternal(aBuilder, aCtx, mVisibleRect, &mBounds);
}
void
nsDisplayBackgroundImage::PaintInternal(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx, const nsRect& aBounds,
+ gfxContext* aCtx, const nsRect& aBounds,
nsRect* aClipRect) {
- gfxContext* ctx = aCtx->ThebesContext();
+ gfxContext* ctx = aCtx;
StyleGeometryBox clip = mBackgroundStyle->mImage.mLayers[mLayer].mClip;
if (clip == StyleGeometryBox::Text) {
if (!GenerateAndPushTextMask(StyleFrame(), aCtx, mBackgroundRect, aBuilder)) {
return;
}
}
@@ -3874,25 +3873,25 @@ nsDisplayThemedBackground::ProvidesFontS
nsRect
nsDisplayThemedBackground::GetPositioningArea()
{
return mBackgroundRect;
}
void
nsDisplayThemedBackground::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx)
+ gfxContext* aCtx)
{
PaintInternal(aBuilder, aCtx, mVisibleRect, nullptr);
}
void
nsDisplayThemedBackground::PaintInternal(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx, const nsRect& aBounds,
+ gfxContext* aCtx, const nsRect& aBounds,
nsRect* aClipRect)
{
// XXXzw this ignores aClipRect.
nsPresContext* presContext = mFrame->PresContext();
nsITheme *theme = presContext->GetTheme();
nsRect drawing(mBackgroundRect);
theme->GetWidgetOverflow(presContext->DeviceContext(), mFrame, mAppearance,
&drawing);
@@ -4121,17 +4120,17 @@ nsDisplayBackgroundColor::BuildLayer(nsD
layer->SetBaseTransform(gfx::Matrix4x4::Translation(aContainerParameters.mOffset.x,
aContainerParameters.mOffset.y, 0));
return layer.forget();
}
void
nsDisplayBackgroundColor::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx)
+ gfxContext* aCtx)
{
if (mColor == Color()) {
return;
}
#if 0
// See https://bugzilla.mozilla.org/show_bug.cgi?id=1148418#c21 for why this
// results in a precision induced rounding issue that makes the rect one
@@ -4146,17 +4145,17 @@ nsDisplayBackgroundColor::Paint(nsDispla
DrawTarget& aDrawTarget = *aCtx->GetDrawTarget();
Rect rect = NSRectToSnappedRect(mBackgroundRect,
mFrame->PresContext()->AppUnitsPerDevPixel(),
aDrawTarget);
ColorPattern color(ToDeviceColor(mColor));
aDrawTarget.FillRect(rect, color);
#else
- gfxContext* ctx = aCtx->ThebesContext();
+ gfxContext* ctx = aCtx;
gfxRect bounds =
nsLayoutUtils::RectToGfxRect(mBackgroundRect,
mFrame->PresContext()->AppUnitsPerDevPixel());
StyleGeometryBox clip = mBackgroundStyle->mImage.mLayers[0].mClip;
if (clip == StyleGeometryBox::Text) {
if (!GenerateAndPushTextMask(mFrame, aCtx, mBackgroundRect, aBuilder)) {
return;
@@ -4253,17 +4252,17 @@ nsDisplayClearBackground::BuildLayer(nsD
nsRect
nsDisplayOutline::GetBounds(nsDisplayListBuilder* aBuilder, bool* aSnap) {
*aSnap = false;
return mFrame->GetVisualOverflowRectRelativeToSelf() + ToReferenceFrame();
}
void
nsDisplayOutline::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) {
+ gfxContext* aCtx) {
// TODO join outlines together
MOZ_ASSERT(mFrame->StyleOutline()->ShouldPaintOutline(),
"Should have not created a nsDisplayOutline!");
nsPoint offset = ToReferenceFrame();
nsCSSRendering::PaintOutline(mFrame->PresContext(), *aCtx, mFrame,
mVisibleRect,
nsRect(offset, mFrame->GetSize()),
@@ -4572,17 +4571,17 @@ nsDisplayCaret::GetBounds(nsDisplayListB
{
*aSnap = true;
// The caret returns a rect in the coordinates of mFrame.
return mBounds;
}
void
nsDisplayCaret::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) {
+ gfxContext* aCtx) {
// Note: Because we exist, we know that the caret is visible, so we don't
// need to check for the caret's visibility.
mCaret->PaintCaret(*aCtx->GetDrawTarget(), mFrame, ToReferenceFrame());
}
void
nsDisplayCaret::CreateWebRenderCommands(wr::DisplayListBuilder& aBuilder,
const StackingContextHelper& aSc,
@@ -4959,17 +4958,17 @@ nsDisplayBorder::CreateWebRenderCommands
CreateBorderImageWebRenderCommands(aBuilder, aSc, aParentCommands, aLayer);
} else if (mBorderRenderer) {
mBorderRenderer->CreateWebRenderCommands(aBuilder, aSc, aLayer);
}
}
void
nsDisplayBorder::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) {
+ gfxContext* aCtx) {
nsPoint offset = ToReferenceFrame();
PaintBorderFlags flags = aBuilder->ShouldSyncDecodeImages()
? PaintBorderFlags::SYNC_DECODE_IMAGES
: PaintBorderFlags();
DrawResult result =
nsCSSRendering::PaintBorder(mFrame->PresContext(), *aCtx, mFrame,
@@ -5065,17 +5064,17 @@ ComputeDisjointRectangles(const nsRegion
// Finish the in-flight rectangle, if there is one.
if (!accumulated.IsEmpty()) {
aRects->AppendElement(accumulated);
}
}
void
nsDisplayBoxShadowOuter::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) {
+ gfxContext* aCtx) {
nsPoint offset = ToReferenceFrame();
nsRect borderRect = mFrame->VisualBorderRectRelativeToSelf() + offset;
nsPresContext* presContext = mFrame->PresContext();
AutoTArray<nsRect,10> rects;
ComputeDisjointRectangles(mVisibleRegion, &rects);
PROFILER_LABEL("nsDisplayBoxShadowOuter", "Paint",
js::ProfileEntry::Category::GRAPHICS);
@@ -5297,28 +5296,28 @@ nsDisplayBoxShadowOuter::ComputeInvalida
}
aInvalidRegion->Or(oldShadow, newShadow);
}
}
void
nsDisplayBoxShadowInner::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) {
+ gfxContext* aCtx) {
nsPoint offset = ToReferenceFrame();
nsRect borderRect = nsRect(offset, mFrame->GetSize());
nsPresContext* presContext = mFrame->PresContext();
AutoTArray<nsRect,10> rects;
ComputeDisjointRectangles(mVisibleRegion, &rects);
PROFILER_LABEL("nsDisplayBoxShadowInner", "Paint",
js::ProfileEntry::Category::GRAPHICS);
DrawTarget* drawTarget = aCtx->GetDrawTarget();
- gfxContext* gfx = aCtx->ThebesContext();
+ gfxContext* gfx = aCtx;
int32_t appUnitsPerDevPixel = mFrame->PresContext()->AppUnitsPerDevPixel();
for (uint32_t i = 0; i < rects.Length(); ++i) {
gfx->Save();
gfx->Clip(NSRectToSnappedRect(rects[i], appUnitsPerDevPixel, *drawTarget));
nsCSSRendering::PaintBoxShadowInner(presContext, *aCtx, mFrame, borderRect);
gfx->Restore();
}
@@ -5579,17 +5578,17 @@ nsDisplayWrapList::GetOpaqueRegion(nsDis
Maybe<nscolor>
nsDisplayWrapList::IsUniform(nsDisplayListBuilder* aBuilder) {
// We could try to do something but let's conservatively just return Nothing.
return Nothing();
}
void nsDisplayWrapList::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) {
+ gfxContext* aCtx) {
NS_ERROR("nsDisplayWrapList should have been flattened away for painting");
}
/**
* Returns true if all descendant display items can be placed in the same
* PaintedLayer --- GetLayerState returns LAYER_INACTIVE or LAYER_NONE,
* and they all have the expected animated geometry root.
*/
@@ -8493,35 +8492,35 @@ nsDisplayMask::ComputeInvalidationRegion
break;
}
}
}
}
void
nsDisplayMask::PaintAsLayer(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx,
+ gfxContext* aCtx,
LayerManager* aManager)
{
MOZ_ASSERT(!ShouldPaintOnMaskLayer(aManager));
// Clip the drawing target by mVisibleRect, which contains the visible
// region of the target frame and its out-of-flow and inflow descendants.
- gfxContext* context = aCtx->ThebesContext();
+ gfxContext* context = aCtx;
Rect bounds =
NSRectToRect(mVisibleRect, mFrame->PresContext()->AppUnitsPerDevPixel());
bounds.RoundOut();
context->Clip(bounds);
imgDrawingParams imgParams(aBuilder->ShouldSyncDecodeImages()
? imgIContainer::FLAG_SYNC_DECODE
: imgIContainer::FLAG_SYNC_DECODE_IF_FAST);
nsRect borderArea = nsRect(ToReferenceFrame(), mFrame->GetSize());
- nsSVGIntegrationUtils::PaintFramesParams params(*aCtx->ThebesContext(),
+ nsSVGIntegrationUtils::PaintFramesParams params(*aCtx,
mFrame, mVisibleRect,
borderArea, aBuilder,
aManager,
mHandleOpacity, imgParams);
ComputeMaskGeometry(params);
nsSVGIntegrationUtils::PaintMaskAndClipPath(params);
@@ -8689,24 +8688,24 @@ nsDisplayFilter::ComputeInvalidationRegi
bool snap;
nsRect bounds = GetBounds(aBuilder, &snap);
aInvalidRegion->Or(*aInvalidRegion, bounds);
}
}
void
nsDisplayFilter::PaintAsLayer(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx,
+ gfxContext* aCtx,
LayerManager* aManager)
{
imgDrawingParams imgParams(aBuilder->ShouldSyncDecodeImages()
? imgIContainer::FLAG_SYNC_DECODE
: imgIContainer::FLAG_SYNC_DECODE_IF_FAST);
nsRect borderArea = nsRect(ToReferenceFrame(), mFrame->GetSize());
- nsSVGIntegrationUtils::PaintFramesParams params(*aCtx->ThebesContext(),
+ nsSVGIntegrationUtils::PaintFramesParams params(*aCtx,
mFrame, mVisibleRect,
borderArea, aBuilder,
aManager,
mHandleOpacity, imgParams);
nsSVGIntegrationUtils::PaintFilter(params);
nsDisplayFilterGeometry::UpdateDrawResult(this, imgParams.result);
}
--- a/layout/painting/nsDisplayList.h
+++ b/layout/painting/nsDisplayList.h
@@ -8,30 +8,30 @@
/*
* structures that represent things to be painted (ordered in z-order),
* used during painting and hit testing
*/
#ifndef NSDISPLAYLIST_H_
#define NSDISPLAYLIST_H_
+#include "gfxContext.h"
#include "mozilla/ArenaAllocator.h"
#include "mozilla/Attributes.h"
#include "mozilla/Array.h"
#include "mozilla/DebugOnly.h"
#include "mozilla/EnumSet.h"
#include "mozilla/Maybe.h"
#include "mozilla/TemplateLib.h" // mozilla::tl::Max
#include "nsCOMPtr.h"
#include "nsContainerFrame.h"
#include "nsPoint.h"
#include "nsRect.h"
#include "nsRegion.h"
#include "nsDisplayListInvalidation.h"
-#include "nsRenderingContext.h"
#include "DisplayListClipState.h"
#include "LayerState.h"
#include "FrameMetrics.h"
#include "mozilla/EnumeratedArray.h"
#include "mozilla/Maybe.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/TimeStamp.h"
#include "mozilla/gfx/UserData.h"
@@ -39,18 +39,18 @@
#include "nsCSSRenderingBorders.h"
#include <stdint.h>
#include "nsTHashtable.h"
#include <stdlib.h>
#include <algorithm>
+class gfxContext;
class nsIContent;
-class nsRenderingContext;
class nsDisplayList;
class nsDisplayTableItem;
class nsISelection;
class nsIScrollableFrame;
class nsDisplayLayerEventRegions;
class nsDisplayScrollInfoLayer;
class nsCaret;
@@ -1912,17 +1912,17 @@ public:
*/
virtual bool ShouldBuildLayerEvenIfInvisible(nsDisplayListBuilder* aBuilder)
{ return false; }
/**
* Actually paint this item to some rendering context.
* Content outside mVisibleRect need not be painted.
* aCtx must be set up as for nsDisplayList::Paint.
*/
- virtual void Paint(nsDisplayListBuilder* aBuilder, nsRenderingContext* aCtx) {}
+ virtual void Paint(nsDisplayListBuilder* aBuilder, gfxContext* aCtx) {}
#ifdef MOZ_DUMP_PAINTING
/**
* Mark this display item as being painted via FrameLayerBuilder::DrawPaintedLayer.
*/
bool Painted() { return mPainted; }
/**
@@ -2456,17 +2456,17 @@ public:
enum {
PAINT_DEFAULT = 0,
PAINT_USE_WIDGET_LAYERS = 0x01,
PAINT_EXISTING_TRANSACTION = 0x04,
PAINT_NO_COMPOSITE = 0x08,
PAINT_COMPRESSED = 0x10
};
already_AddRefed<LayerManager> PaintRoot(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx,
+ gfxContext* aCtx,
uint32_t aFlags);
/**
* Get the bounds. Takes the union of the bounds of all children.
* The result is not cached.
*/
nsRect GetBounds(nsDisplayListBuilder* aBuilder) const;
/**
@@ -2681,17 +2681,17 @@ public:
* save code size. We use this for infrequently-used item types.
*/
class nsDisplayGeneric : public nsDisplayItem {
public:
typedef void (* PaintCallback)(nsIFrame* aFrame, DrawTarget* aDrawTarget,
const nsRect& aDirtyRect, nsPoint aFramePt);
// XXX: should be removed eventually
- typedef void (* OldPaintCallback)(nsIFrame* aFrame, nsRenderingContext* aCtx,
+ typedef void (* OldPaintCallback)(nsIFrame* aFrame, gfxContext* aCtx,
const nsRect& aDirtyRect, nsPoint aFramePt);
nsDisplayGeneric(nsDisplayListBuilder* aBuilder, nsIFrame* aFrame,
PaintCallback aPaint, const char* aName, Type aType)
: nsDisplayItem(aBuilder, aFrame)
, mPaint(aPaint)
, mOldPaint(nullptr)
, mName(aName)
@@ -2713,17 +2713,17 @@ public:
}
#ifdef NS_BUILD_REFCNT_LOGGING
virtual ~nsDisplayGeneric() {
MOZ_COUNT_DTOR(nsDisplayGeneric);
}
#endif
virtual void Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) override {
+ gfxContext* aCtx) override {
MOZ_ASSERT(!!mPaint != !!mOldPaint);
if (mPaint) {
mPaint(mFrame, aCtx->GetDrawTarget(), mVisibleRect, ToReferenceFrame());
} else {
mOldPaint(mFrame, aCtx, mVisibleRect, ToReferenceFrame());
}
}
NS_DISPLAY_DECL_NAME(mName, mType)
@@ -2760,17 +2760,17 @@ public:
MOZ_COUNT_CTOR(nsDisplayReflowCount);
}
#ifdef NS_BUILD_REFCNT_LOGGING
virtual ~nsDisplayReflowCount() {
MOZ_COUNT_DTOR(nsDisplayReflowCount);
}
#endif
- virtual void Paint(nsDisplayListBuilder* aBuilder, nsRenderingContext* aCtx) override {
+ virtual void Paint(nsDisplayListBuilder* aBuilder, gfxContext* aCtx) override {
mFrame->PresContext()->PresShell()->PaintCount(mFrameName, aCtx,
mFrame->PresContext(),
mFrame, ToReferenceFrame(),
mColor);
}
NS_DISPLAY_DECL_NAME("nsDisplayReflowCount", TYPE_REFLOW_COUNT)
protected:
const char* mFrameName;
@@ -2817,17 +2817,17 @@ protected:
class nsDisplayCaret : public nsDisplayItem {
public:
nsDisplayCaret(nsDisplayListBuilder* aBuilder, nsIFrame* aCaretFrame);
#ifdef NS_BUILD_REFCNT_LOGGING
virtual ~nsDisplayCaret();
#endif
virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder, bool* aSnap) override;
- virtual void Paint(nsDisplayListBuilder* aBuilder, nsRenderingContext* aCtx) override;
+ virtual void Paint(nsDisplayListBuilder* aBuilder, gfxContext* aCtx) override;
NS_DISPLAY_DECL_NAME("Caret", TYPE_CARET)
virtual LayerState GetLayerState(nsDisplayListBuilder* aBuilder,
LayerManager* aManager,
const ContainerLayerParameters& aParameters) override;
virtual already_AddRefed<Layer> BuildLayer(nsDisplayListBuilder* aBuilder,
LayerManager* aManager,
const ContainerLayerParameters& aContainerParameters) override;
@@ -2862,17 +2862,17 @@ public:
virtual already_AddRefed<Layer> BuildLayer(nsDisplayListBuilder* aBuilder,
LayerManager* aManager,
const ContainerLayerParameters& aContainerParameters) override;
virtual void CreateWebRenderCommands(mozilla::wr::DisplayListBuilder& aBuilder,
const StackingContextHelper& aSc,
nsTArray<WebRenderParentCommand>& aParentCommands,
WebRenderDisplayItemLayer* aLayer) override;
- virtual void Paint(nsDisplayListBuilder* aBuilder, nsRenderingContext* aCtx) override;
+ virtual void Paint(nsDisplayListBuilder* aBuilder, gfxContext* aCtx) override;
NS_DISPLAY_DECL_NAME("Border", TYPE_BORDER)
virtual nsDisplayItemGeometry* AllocateGeometry(nsDisplayListBuilder* aBuilder) override;
virtual void ComputeInvalidationRegion(nsDisplayListBuilder* aBuilder,
const nsDisplayItemGeometry* aGeometry,
nsRegion* aInvalidRegion) override;
@@ -2975,17 +2975,17 @@ public:
virtual LayerState GetLayerState(nsDisplayListBuilder* aBuilder,
LayerManager* aManager,
const ContainerLayerParameters& aParameters) override;
virtual already_AddRefed<Layer> BuildLayer(nsDisplayListBuilder* aBuilder,
LayerManager* aManager,
const ContainerLayerParameters& aContainerParameters) override;
- virtual void Paint(nsDisplayListBuilder* aBuilder, nsRenderingContext* aCtx) override;
+ virtual void Paint(nsDisplayListBuilder* aBuilder, gfxContext* aCtx) override;
virtual void WriteDebugInfo(std::stringstream& aStream) override;
NS_DISPLAY_DECL_NAME("SolidColor", TYPE_SOLID_COLOR)
private:
nsRect mBounds;
};
@@ -3028,17 +3028,17 @@ public:
} else {
aInvalidRegion->Or(geometry->mRegion.GetBounds(), mRegion.GetBounds());
}
}
protected:
virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder, bool* aSnap) override;
- virtual void Paint(nsDisplayListBuilder* aBuilder, nsRenderingContext* aCtx) override;
+ virtual void Paint(nsDisplayListBuilder* aBuilder, gfxContext* aCtx) override;
virtual void WriteDebugInfo(std::stringstream& aStream) override;
NS_DISPLAY_DECL_NAME("SolidColorRegion", TYPE_SOLID_COLOR_REGION)
private:
nsRegion mRegion;
Color mColor;
};
@@ -3118,17 +3118,17 @@ public:
nsRegion* aVisibleRegion) override;
virtual nsRegion GetOpaqueRegion(nsDisplayListBuilder* aBuilder,
bool* aSnap) override;
virtual mozilla::Maybe<nscolor> IsUniform(nsDisplayListBuilder* aBuilder) override;
/**
* GetBounds() returns the background painting area.
*/
virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder, bool* aSnap) override;
- virtual void Paint(nsDisplayListBuilder* aBuilder, nsRenderingContext* aCtx) override;
+ virtual void Paint(nsDisplayListBuilder* aBuilder, gfxContext* aCtx) override;
virtual uint32_t GetPerFrameKey() override;
NS_DISPLAY_DECL_NAME("Background", TYPE_BACKGROUND)
/**
* Return the background positioning area.
* (GetBounds() returns the background painting area.)
* Can be called only when mBackgroundStyle is non-null.
*/
@@ -3167,17 +3167,17 @@ public:
protected:
typedef class mozilla::layers::ImageContainer ImageContainer;
typedef class mozilla::layers::ImageLayer ImageLayer;
bool CanBuildWebRenderDisplayItems(LayerManager* aManager);
bool TryOptimizeToImageLayer(LayerManager* aManager, nsDisplayListBuilder* aBuilder);
nsRect GetBoundsInternal(nsDisplayListBuilder* aBuilder);
- void PaintInternal(nsDisplayListBuilder* aBuilder, nsRenderingContext* aCtx,
+ void PaintInternal(nsDisplayListBuilder* aBuilder, gfxContext* aCtx,
const nsRect& aBounds, nsRect* aClipRect);
virtual nsIFrame* StyleFrame() { return mFrame; }
// Determine whether we want to be separated into our own layer, independent
// of whether this item can actually be layerized.
enum ImageLayerization {
WHENEVER_POSSIBLE,
@@ -3268,17 +3268,17 @@ public:
bool* aSnap) override;
virtual mozilla::Maybe<nscolor> IsUniform(nsDisplayListBuilder* aBuilder) override;
virtual bool ProvidesFontSmoothingBackgroundColor(nscolor* aColor) override;
/**
* GetBounds() returns the background painting area.
*/
virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder, bool* aSnap) override;
- virtual void Paint(nsDisplayListBuilder* aBuilder, nsRenderingContext* aCtx) override;
+ virtual void Paint(nsDisplayListBuilder* aBuilder, gfxContext* aCtx) override;
NS_DISPLAY_DECL_NAME("ThemedBackground", TYPE_THEMED_BACKGROUND)
/**
* Return the background positioning area.
* (GetBounds() returns the background painting area.)
* Can be called only when mBackgroundStyle is non-null.
*/
nsRect GetPositioningArea();
@@ -3297,17 +3297,17 @@ public:
virtual void ComputeInvalidationRegion(nsDisplayListBuilder* aBuilder,
const nsDisplayItemGeometry* aGeometry,
nsRegion* aInvalidRegion) override;
virtual void WriteDebugInfo(std::stringstream& aStream) override;
protected:
nsRect GetBoundsInternal();
- void PaintInternal(nsDisplayListBuilder* aBuilder, nsRenderingContext* aCtx,
+ void PaintInternal(nsDisplayListBuilder* aBuilder, gfxContext* aCtx,
const nsRect& aBounds, nsRect* aClipRect);
nsRect mBackgroundRect;
nsRect mBounds;
nsITheme::Transparency mThemeTransparency;
uint8_t mAppearance;
};
@@ -3324,17 +3324,17 @@ public:
, mBackgroundRect(aBackgroundRect)
, mBackgroundStyle(aBackgroundStyle)
, mColor(Color::FromABGR(aColor))
{ }
virtual LayerState GetLayerState(nsDisplayListBuilder* aBuilder,
LayerManager* aManager,
const ContainerLayerParameters& aParameters) override;
- virtual void Paint(nsDisplayListBuilder* aBuilder, nsRenderingContext* aCtx) override;
+ virtual void Paint(nsDisplayListBuilder* aBuilder, gfxContext* aCtx) override;
virtual already_AddRefed<Layer> BuildLayer(nsDisplayListBuilder* aBuilder,
LayerManager* aManager,
const ContainerLayerParameters& aContainerParameters) override;
virtual nsRegion GetOpaqueRegion(nsDisplayListBuilder* aBuilder,
bool* aSnap) override;
virtual mozilla::Maybe<nscolor> IsUniform(nsDisplayListBuilder* aBuilder) override;
virtual void HitTest(nsDisplayListBuilder* aBuilder, const nsRect& aRect,
@@ -3453,17 +3453,17 @@ public:
mBounds = GetBoundsInternal();
}
#ifdef NS_BUILD_REFCNT_LOGGING
virtual ~nsDisplayBoxShadowOuter() {
MOZ_COUNT_DTOR(nsDisplayBoxShadowOuter);
}
#endif
- virtual void Paint(nsDisplayListBuilder* aBuilder, nsRenderingContext* aCtx) override;
+ virtual void Paint(nsDisplayListBuilder* aBuilder, gfxContext* aCtx) override;
virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder, bool* aSnap) override;
virtual bool IsInvisibleInRect(const nsRect& aRect) override;
virtual bool ComputeVisibility(nsDisplayListBuilder* aBuilder,
nsRegion* aVisibleRegion) override;
NS_DISPLAY_DECL_NAME("BoxShadowOuter", TYPE_BOX_SHADOW_OUTER)
virtual void ComputeInvalidationRegion(nsDisplayListBuilder* aBuilder,
const nsDisplayItemGeometry* aGeometry,
@@ -3518,17 +3518,17 @@ public:
MOZ_COUNT_CTOR(nsDisplayBoxShadowInner);
}
#ifdef NS_BUILD_REFCNT_LOGGING
virtual ~nsDisplayBoxShadowInner() {
MOZ_COUNT_DTOR(nsDisplayBoxShadowInner);
}
#endif
- virtual void Paint(nsDisplayListBuilder* aBuilder, nsRenderingContext* aCtx) override;
+ virtual void Paint(nsDisplayListBuilder* aBuilder, gfxContext* aCtx) override;
virtual bool ComputeVisibility(nsDisplayListBuilder* aBuilder,
nsRegion* aVisibleRegion) override;
NS_DISPLAY_DECL_NAME("BoxShadowInner", TYPE_BOX_SHADOW_INNER)
virtual nsDisplayItemGeometry* AllocateGeometry(nsDisplayListBuilder* aBuilder) override
{
return new nsDisplayBoxShadowInnerGeometry(this, aBuilder);
}
@@ -3591,17 +3591,17 @@ public:
LayerManager* aManager,
const ContainerLayerParameters& aContainerParameters) override;
virtual void CreateWebRenderCommands(mozilla::wr::DisplayListBuilder& aBuilder,
const StackingContextHelper& aSc,
nsTArray<WebRenderParentCommand>& aParentCommands,
mozilla::layers::WebRenderDisplayItemLayer* aLayer) override;
virtual bool IsInvisibleInRect(const nsRect& aRect) override;
virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder, bool* aSnap) override;
- virtual void Paint(nsDisplayListBuilder* aBuilder, nsRenderingContext* aCtx) override;
+ virtual void Paint(nsDisplayListBuilder* aBuilder, gfxContext* aCtx) override;
NS_DISPLAY_DECL_NAME("Outline", TYPE_OUTLINE)
mozilla::Maybe<nsCSSBorderRenderer> mBorderRenderer;
};
/**
* A class that lets you receive events within the frame bounds but never paints.
*/
@@ -3776,17 +3776,17 @@ public:
mVisibleRect.UnionRect(mBaseVisibleRect, mList.GetVisibleRect());
}
virtual void HitTest(nsDisplayListBuilder* aBuilder, const nsRect& aRect,
HitTestState* aState, nsTArray<nsIFrame*> *aOutFrames) override;
virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder, bool* aSnap) override;
virtual nsRegion GetOpaqueRegion(nsDisplayListBuilder* aBuilder,
bool* aSnap) override;
virtual mozilla::Maybe<nscolor> IsUniform(nsDisplayListBuilder* aBuilder) override;
- virtual void Paint(nsDisplayListBuilder* aBuilder, nsRenderingContext* aCtx) override;
+ virtual void Paint(nsDisplayListBuilder* aBuilder, gfxContext* aCtx) override;
virtual bool ComputeVisibility(nsDisplayListBuilder* aBuilder,
nsRegion* aVisibleRegion) override;
virtual bool TryMerge(nsDisplayItem* aItem) override {
return false;
}
virtual void GetMergedFrames(nsTArray<nsIFrame*>* aFrames) override
{
aFrames->AppendElements(mMergedFrames);
@@ -4428,17 +4428,17 @@ public:
virtual void ComputeInvalidationRegion(nsDisplayListBuilder* aBuilder,
const nsDisplayItemGeometry* aGeometry,
nsRegion* aInvalidRegion) override;
#ifdef MOZ_DUMP_PAINTING
void PrintEffects(nsACString& aTo);
#endif
void PaintAsLayer(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx,
+ gfxContext* aCtx,
LayerManager* aManager);
/*
* Paint mask onto aMaskContext in mFrame's coordinate space and
* return whether the mask layer was painted successfully.
*/
bool PaintMask(nsDisplayListBuilder* aBuilder, gfxContext* aMaskContext);
@@ -4489,17 +4489,17 @@ public:
virtual void ComputeInvalidationRegion(nsDisplayListBuilder* aBuilder,
const nsDisplayItemGeometry* aGeometry,
nsRegion* aInvalidRegion) override;
#ifdef MOZ_DUMP_PAINTING
void PrintEffects(nsACString& aTo);
#endif
void PaintAsLayer(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx,
+ gfxContext* aCtx,
LayerManager* aManager);
};
/* A display item that applies a transformation to all of its descendant
* elements. This wrapper should only be used if there is a transform applied
* to the root element.
*
* The reason that a "bounds" rect is involved in transform calculations is
--- a/layout/painting/nsImageRenderer.cpp
+++ b/layout/painting/nsImageRenderer.cpp
@@ -5,24 +5,24 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
/* utility functions for drawing borders and backgrounds */
#include "nsImageRenderer.h"
#include "mozilla/webrender/WebRenderAPI.h"
+#include "gfxContext.h"
#include "gfxDrawable.h"
#include "ImageOps.h"
#include "mozilla/layers/StackingContextHelper.h"
#include "nsContentUtils.h"
#include "nsCSSRendering.h"
#include "nsCSSRenderingGradients.h"
#include "nsIFrame.h"
-#include "nsRenderingContext.h"
#include "nsStyleStructInlines.h"
#include "nsSVGEffects.h"
#include "nsSVGIntegrationUtils.h"
using namespace mozilla;
using namespace mozilla::gfx;
using namespace mozilla::image;
using namespace mozilla::layers;
@@ -457,17 +457,17 @@ RGBALuminanceOperation(uint8_t *aData,
((*pixel & 0x000000FF) * blueFactor)) >> 8) << 24;
pixel++;
}
}
}
DrawResult
nsImageRenderer::Draw(nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
const nsRect& aDirtyRect,
const nsRect& aDest,
const nsRect& aFill,
const nsPoint& aAnchor,
const nsSize& aRepeatSize,
const CSSIntRect& aSrc,
float aOpacity)
{
@@ -477,17 +477,17 @@ nsImageRenderer::Draw(nsPresContext*
}
if (aDest.IsEmpty() || aFill.IsEmpty() ||
mSize.width <= 0 || mSize.height <= 0) {
return DrawResult::SUCCESS;
}
SamplingFilter samplingFilter = nsLayoutUtils::GetSamplingFilterForFrame(mForFrame);
DrawResult result = DrawResult::SUCCESS;
- RefPtr<gfxContext> ctx = aRenderingContext.ThebesContext();
+ RefPtr<gfxContext> ctx = &aRenderingContext;
IntRect tmpDTRect;
if (ctx->CurrentOp() != CompositionOp::OP_OVER || mMaskOp == NS_STYLE_MASK_MODE_LUMINANCE) {
gfxRect clipRect = ctx->GetClipExtents();
tmpDTRect = RoundedOut(ToRect(clipRect));
if (tmpDTRect.IsEmpty()) {
return DrawResult::SUCCESS;
}
@@ -562,21 +562,21 @@ nsImageRenderer::Draw(nsPresContext*
return result;
}
RGBALuminanceOperation(map.mData, map.mStride, maskData->GetSize());
maskData->Unmap();
surf = maskData;
}
- DrawTarget* dt = aRenderingContext.ThebesContext()->GetDrawTarget();
+ DrawTarget* dt = aRenderingContext.GetDrawTarget();
dt->DrawSurface(surf, Rect(tmpDTRect.x, tmpDTRect.y, tmpDTRect.width, tmpDTRect.height),
Rect(0, 0, tmpDTRect.width, tmpDTRect.height),
DrawSurfaceOptions(SamplingFilter::POINT),
- DrawOptions(1.0f, aRenderingContext.ThebesContext()->CurrentOp()));
+ DrawOptions(1.0f, aRenderingContext.CurrentOp()));
}
return result;
}
DrawResult
nsImageRenderer::BuildWebRenderDisplayItems(nsPresContext* aPresContext,
mozilla::wr::DisplayListBuilder& aBuilder,
@@ -681,17 +681,17 @@ nsImageRenderer::DrawableForElement(cons
RefPtr<gfxDrawable> drawable = new gfxSurfaceDrawable(
mImageElementSurface.GetSourceSurface().get(),
mImageElementSurface.mSize);
return drawable.forget();
}
DrawResult
nsImageRenderer::DrawLayer(nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
const nsRect& aDest,
const nsRect& aFill,
const nsPoint& aAnchor,
const nsRect& aDirty,
const nsSize& aRepeatSize,
float aOpacity)
{
if (!IsReady()) {
@@ -842,17 +842,17 @@ RequiresScaling(const nsRect& aFi
return (aHFill != NS_STYLE_BORDER_IMAGE_REPEAT_STRETCH ||
aVFill != NS_STYLE_BORDER_IMAGE_REPEAT_STRETCH) &&
(aUnitSize.width != aFill.width ||
aUnitSize.height != aFill.height);
}
DrawResult
nsImageRenderer::DrawBorderImageComponent(nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
const nsRect& aDirtyRect,
const nsRect& aFill,
const CSSIntRect& aSrc,
uint8_t aHFill,
uint8_t aVFill,
const nsSize& aUnitSize,
uint8_t aIndex,
const Maybe<nsSize>& aSVGViewportSize,
@@ -896,46 +896,46 @@ nsImageRenderer::DrawBorderImageComponen
// to draw to a temporary surface inside ClippedImage, we don't cache that
// temporary surface since we immediately throw the ClippedImage we create
// here away.) However, if we did cache, we'd need to know when to
// invalidate that cache, and it's not clear that it's worth the trouble
// since using border-image with -moz-element is rare.
RefPtr<gfxDrawable> drawable =
DrawableForElement(nsRect(nsPoint(), mSize),
- *aRenderingContext.ThebesContext());
+ aRenderingContext);
if (!drawable) {
NS_WARNING("Could not create drawable for element");
return DrawResult::TEMPORARY_ERROR;
}
nsCOMPtr<imgIContainer> image(ImageOps::CreateFromDrawable(drawable));
subImage = ImageOps::Clip(image, srcRect, aSVGViewportSize);
}
MOZ_ASSERT_IF(aSVGViewportSize,
subImage->GetType() == imgIContainer::TYPE_VECTOR);
SamplingFilter samplingFilter = nsLayoutUtils::GetSamplingFilterForFrame(mForFrame);
if (!RequiresScaling(aFill, aHFill, aVFill, aUnitSize)) {
- return nsLayoutUtils::DrawSingleImage(*aRenderingContext.ThebesContext(),
+ return nsLayoutUtils::DrawSingleImage(aRenderingContext,
aPresContext,
subImage,
samplingFilter,
aFill, aDirtyRect,
/* no SVGImageContext */ Nothing(),
drawFlags);
}
nsSize repeatSize;
nsRect fillRect(aFill);
nsRect tile = ComputeTile(fillRect, aHFill, aVFill, aUnitSize, repeatSize);
CSSIntSize imageSize(srcRect.width, srcRect.height);
- return nsLayoutUtils::DrawBackgroundImage(*aRenderingContext.ThebesContext(),
+ return nsLayoutUtils::DrawBackgroundImage(aRenderingContext,
mForFrame, aPresContext,
subImage, imageSize, samplingFilter,
tile, fillRect, repeatSize,
tile.TopLeft(), aDirtyRect,
drawFlags,
ExtendMode::CLAMP, 1.0);
}
--- a/layout/painting/nsImageRenderer.h
+++ b/layout/painting/nsImageRenderer.h
@@ -189,17 +189,17 @@ public:
const nsSize& aDefaultSize);
/**
* Draws the image to the target rendering context using
* {background|mask}-specific arguments.
* @see nsLayoutUtils::DrawImage() for parameters.
*/
DrawResult DrawLayer(nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
const nsRect& aDest,
const nsRect& aFill,
const nsPoint& aAnchor,
const nsRect& aDirty,
const nsSize& aRepeatSize,
float aOpacity);
/**
@@ -235,17 +235,17 @@ public:
* Pass Nothing() if we can read a valid viewport size or aspect-ratio from
* the drawing image directly, otherwise, pass Some() with viewport size
* evaluated from default sizing algorithm.
* aHasIntrinsicRatio is used to record if the source image has fixed
* intrinsic ratio.
*/
DrawResult
DrawBorderImageComponent(nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
const nsRect& aDirtyRect,
const nsRect& aFill,
const mozilla::CSSIntRect& aSrc,
uint8_t aHFill,
uint8_t aVFill,
const nsSize& aUnitSize,
uint8_t aIndex,
const mozilla::Maybe<nsSize>& aSVGViewportSize,
@@ -271,17 +271,17 @@ private:
/**
* Draws the image to the target rendering context.
* aSrc is a rect on the source image which will be mapped to aDest; it's
* currently only used for gradients.
*
* @see nsLayoutUtils::DrawImage() for other parameters.
*/
DrawResult Draw(nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
const nsRect& aDirtyRect,
const nsRect& aDest,
const nsRect& aFill,
const nsPoint& aAnchor,
const nsSize& aRepeatSize,
const mozilla::CSSIntRect& aSrc,
float aOpacity = 1.0);
--- a/layout/printing/nsPrintEngine.cpp
+++ b/layout/printing/nsPrintEngine.cpp
@@ -68,16 +68,17 @@ static const char kPrintingPromptService
// FrameSet
#include "nsIDocument.h"
// Focus
#include "nsISelectionController.h"
// Misc
+#include "gfxContext.h"
#include "mozilla/gfx/DrawEventRecorder.h"
#include "mozilla/layout/RemotePrintJobChild.h"
#include "nsISupportsUtils.h"
#include "nsIScriptContext.h"
#include "nsIDOMDocument.h"
#include "nsISelectionListener.h"
#include "nsISelectionPrivate.h"
#include "nsIDOMRange.h"
@@ -88,17 +89,16 @@ static const char kPrintingPromptService
#include "nsLayoutUtils.h"
#include "mozilla/Preferences.h"
#include "nsWidgetsCID.h"
#include "nsIDeviceContextSpec.h"
#include "nsDeviceContextSpecProxy.h"
#include "nsViewManager.h"
#include "nsView.h"
-#include "nsRenderingContext.h"
#include "nsIPageSequenceFrame.h"
#include "nsIURL.h"
#include "nsIContentViewerEdit.h"
#include "nsIContentViewerFile.h"
#include "nsIInterfaceRequestor.h"
#include "nsIInterfaceRequestorUtils.h"
#include "nsIDocShellTreeOwner.h"
@@ -3808,17 +3808,17 @@ static void RootFrameList(nsPresContext*
}
}
/** ---------------------------------------------------
* Dumps Frames for Printing
*/
static void DumpFrames(FILE* out,
nsPresContext* aPresContext,
- nsRenderingContext * aRendContext,
+ gfxContext * aRendContext,
nsIFrame * aFrame,
int32_t aLevel)
{
NS_ASSERTION(out, "Pointer is null!");
NS_ASSERTION(aPresContext, "Pointer is null!");
NS_ASSERTION(aRendContext, "Pointer is null!");
NS_ASSERTION(aFrame, "Pointer is null!");
--- a/layout/style/nsRuleNode.cpp
+++ b/layout/style/nsRuleNode.cpp
@@ -22,16 +22,17 @@
#include "mozilla/LookAndFeel.h"
#include "mozilla/Maybe.h"
#include "mozilla/OperatorNewExtensions.h"
#include "mozilla/Unused.h"
#include "mozilla/css/Declaration.h"
#include "mozilla/TypeTraits.h"
+#include "gfxContext.h"
#include "nsAlgorithm.h" // for clamped()
#include "nscore.h"
#include "nsCRT.h" // for IsAscii()
#include "nsIWidget.h"
#include "nsIPresShell.h"
#include "nsFontMetrics.h"
#include "gfxFont.h"
#include "nsCSSAnonBoxes.h"
@@ -46,17 +47,16 @@
#include "nsIStyleRule.h"
#include "nsBidiUtils.h"
#include "nsStyleStructInlines.h"
#include "nsCSSProps.h"
#include "nsTArray.h"
#include "nsContentUtils.h"
#include "CSSCalc.h"
#include "nsPrintfCString.h"
-#include "nsRenderingContext.h"
#include "nsStyleUtil.h"
#include "nsIDocument.h"
#include "prtime.h"
#include "CSSVariableResolver.h"
#include "nsCSSParser.h"
#include "CounterStyleManager.h"
#include "nsCSSPropertyIDSet.h"
#include "mozilla/RuleNodeCacheConditions.h"
@@ -485,19 +485,19 @@ static nsSize CalcViewportUnitsScale(nsP
nsIScrollableFrame* scrollFrame =
aPresContext->PresShell()->GetRootScrollFrameAsScrollable();
if (scrollFrame) {
ScrollbarStyles styles(scrollFrame->GetScrollbarStyles());
if (styles.mHorizontal == NS_STYLE_OVERFLOW_SCROLL ||
styles.mVertical == NS_STYLE_OVERFLOW_SCROLL) {
// Gather scrollbar size information.
- nsRenderingContext context(
- aPresContext->PresShell()->CreateReferenceRenderingContext());
- nsMargin sizes(scrollFrame->GetDesiredScrollbarSizes(aPresContext, &context));
+ RefPtr<gfxContext> context =
+ aPresContext->PresShell()->CreateReferenceRenderingContext();
+ nsMargin sizes(scrollFrame->GetDesiredScrollbarSizes(aPresContext, context));
if (styles.mHorizontal == NS_STYLE_OVERFLOW_SCROLL) {
// 'overflow-x: scroll' means we must consider the horizontal scrollbar,
// which affects the scale of viewport height units.
viewportSize.height -= sizes.TopBottom();
}
if (styles.mVertical == NS_STYLE_OVERFLOW_SCROLL) {
--- a/layout/svg/SVGGeometryFrame.cpp
+++ b/layout/svg/SVGGeometryFrame.cpp
@@ -13,17 +13,16 @@
#include "gfxUtils.h"
#include "mozilla/gfx/2D.h"
#include "mozilla/gfx/Helpers.h"
#include "mozilla/RefPtr.h"
#include "mozilla/SVGContextPaint.h"
#include "nsDisplayList.h"
#include "nsGkAtoms.h"
#include "nsLayoutUtils.h"
-#include "nsRenderingContext.h"
#include "nsSVGEffects.h"
#include "nsSVGIntegrationUtils.h"
#include "nsSVGMarkerFrame.h"
#include "SVGGeometryElement.h"
#include "nsSVGUtils.h"
#include "mozilla/ArrayUtils.h"
#include "SVGAnimatedTransformList.h"
#include "SVGContentUtils.h"
@@ -74,17 +73,17 @@ public:
}
#endif
NS_DISPLAY_DECL_NAME("nsDisplaySVGGeometry", TYPE_SVG_GEOMETRY)
virtual void HitTest(nsDisplayListBuilder* aBuilder, const nsRect& aRect,
HitTestState* aState, nsTArray<nsIFrame*> *aOutFrames) override;
virtual void Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) override;
+ gfxContext* aCtx) override;
nsDisplayItemGeometry* AllocateGeometry(nsDisplayListBuilder* aBuilder) override
{
return new nsDisplayItemGenericImageGeometry(this, aBuilder);
}
void ComputeInvalidationRegion(nsDisplayListBuilder* aBuilder,
const nsDisplayItemGeometry* aGeometry,
@@ -105,17 +104,17 @@ nsDisplaySVGGeometry::HitTest(nsDisplayL
frame->PresContext()->AppUnitsPerCSSPixel();
if (frame->GetFrameForPoint(userSpacePt)) {
aOutFrames->AppendElement(frame);
}
}
void
nsDisplaySVGGeometry::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx)
+ gfxContext* aCtx)
{
uint32_t appUnitsPerDevPixel = mFrame->PresContext()->AppUnitsPerDevPixel();
// ToReferenceFrame includes our mRect offset, but painting takes
// account of that too. To avoid double counting, we subtract that
// here.
nsPoint offset = ToReferenceFrame() - mFrame->GetPosition();
@@ -123,17 +122,17 @@ nsDisplaySVGGeometry::Paint(nsDisplayLis
nsLayoutUtils::PointToGfxPoint(offset, appUnitsPerDevPixel);
gfxMatrix tm = nsSVGUtils::GetCSSPxToDevPxMatrix(mFrame) *
gfxMatrix::Translation(devPixelOffset);
imgDrawingParams imgParams(aBuilder->ShouldSyncDecodeImages()
? imgIContainer::FLAG_SYNC_DECODE
: imgIContainer::FLAG_SYNC_DECODE_IF_FAST);
- static_cast<SVGGeometryFrame*>(mFrame)->PaintSVG(*aCtx->ThebesContext(),
+ static_cast<SVGGeometryFrame*>(mFrame)->PaintSVG(*aCtx,
tm, imgParams);
nsDisplayItemGenericImageGeometry::UpdateDrawResult(this, imgParams.result);
}
void
nsDisplaySVGGeometry::ComputeInvalidationRegion(
nsDisplayListBuilder* aBuilder,
--- a/layout/svg/SVGTextFrame.cpp
+++ b/layout/svg/SVGTextFrame.cpp
@@ -4,33 +4,33 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
// Main header first:
#include "SVGTextFrame.h"
// Keep others in (case-insensitive) order:
#include "DOMSVGPoint.h"
#include "gfx2DGlue.h"
+#include "gfxContext.h"
#include "gfxFont.h"
#include "gfxSkipChars.h"
#include "gfxTypes.h"
#include "gfxUtils.h"
#include "LookAndFeel.h"
#include "mozilla/gfx/2D.h"
#include "mozilla/gfx/PatternHelpers.h"
#include "mozilla/Likely.h"
#include "nsAlgorithm.h"
#include "nsBlockFrame.h"
#include "nsCaret.h"
#include "nsContentUtils.h"
#include "nsGkAtoms.h"
#include "nsIDOMSVGLength.h"
#include "nsISelection.h"
#include "nsQuickSort.h"
-#include "nsRenderingContext.h"
#include "nsSVGEffects.h"
#include "nsSVGOuterSVGFrame.h"
#include "nsSVGPaintServerFrame.h"
#include "mozilla/dom/SVGRect.h"
#include "nsSVGIntegrationUtils.h"
#include "nsSVGUtils.h"
#include "nsTArray.h"
#include "nsTextFrame.h"
@@ -2741,22 +2741,22 @@ public:
*
* @param aContext The context to use for painting.
* @param aFrame The nsTextFrame to paint.
* @param aCanvasTM The transformation matrix to set when painting; this
* should be the FOR_OUTERSVG_TM canvas TM of the text, so that
* paint servers are painted correctly.
* @param aShouldPaintSVGGlyphs Whether SVG glyphs should be painted.
*/
- SVGTextDrawPathCallbacks(nsRenderingContext* aContext,
+ SVGTextDrawPathCallbacks(gfxContext* aContext,
nsTextFrame* aFrame,
const gfxMatrix& aCanvasTM,
bool aShouldPaintSVGGlyphs)
: DrawPathCallbacks(aShouldPaintSVGGlyphs),
- gfx(aContext->ThebesContext()),
+ gfx(aContext),
mFrame(aFrame),
mCanvasTM(aCanvasTM)
{
}
void NotifySelectionBackgroundNeedsFill(const Rect& aBackgroundRect,
nscolor aColor,
DrawTarget& aDrawTarget) override;
@@ -3071,17 +3071,17 @@ public:
virtual void DisableComponentAlpha() override {
mDisableSubpixelAA = true;
}
virtual void HitTest(nsDisplayListBuilder* aBuilder, const nsRect& aRect,
HitTestState* aState,
nsTArray<nsIFrame*> *aOutFrames) override;
virtual void Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) override;
+ gfxContext* aCtx) override;
nsDisplayItemGeometry* AllocateGeometry(nsDisplayListBuilder* aBuilder) override
{
return new nsDisplayItemGenericImageGeometry(this, aBuilder);
}
virtual nsRect GetComponentAlphaBounds(nsDisplayListBuilder* aBuilder) override {
bool snap;
return GetBounds(aBuilder, &snap);
}
@@ -3106,17 +3106,17 @@ nsDisplaySVGText::HitTest(nsDisplayListB
nsIFrame* target = frame->GetFrameForPoint(userSpacePt);
if (target) {
aOutFrames->AppendElement(target);
}
}
void
nsDisplaySVGText::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx)
+ gfxContext* aCtx)
{
DrawTargetAutoDisableSubpixelAntialiasing
disable(aCtx->GetDrawTarget(), mDisableSubpixelAA);
uint32_t appUnitsPerDevPixel = mFrame->PresContext()->AppUnitsPerDevPixel();
// ToReferenceFrame includes our mRect offset, but painting takes
// account of that too. To avoid double counting, we subtract that
@@ -3124,17 +3124,17 @@ nsDisplaySVGText::Paint(nsDisplayListBui
nsPoint offset = ToReferenceFrame() - mFrame->GetPosition();
gfxPoint devPixelOffset =
nsLayoutUtils::PointToGfxPoint(offset, appUnitsPerDevPixel);
gfxMatrix tm = nsSVGUtils::GetCSSPxToDevPxMatrix(mFrame) *
gfxMatrix::Translation(devPixelOffset);
- gfxContext* ctx = aCtx->ThebesContext();
+ gfxContext* ctx = aCtx;
ctx->Save();
imgDrawingParams imgParams(aBuilder->ShouldSyncDecodeImages()
? imgIContainer::FLAG_SYNC_DECODE
: imgIContainer::FLAG_SYNC_DECODE_IF_FAST);
static_cast<SVGTextFrame*>(mFrame)->PaintSVG(*ctx, tm, imgParams);
nsDisplayItemGenericImageGeometry::UpdateDrawResult(this, imgParams.result);
ctx->Restore();
}
@@ -3648,17 +3648,16 @@ SVGTextFrame::PaintSVG(gfxContext& aCont
nsIFrame* caretFrame = caret->GetPaintGeometry(&caretRect);
TextRenderedRunIterator it(this, TextRenderedRunIterator::eVisibleFrames);
TextRenderedRun run = it.Current();
SVGContextPaint* outerContextPaint =
SVGContextPaint::GetContextPaint(mContent);
- nsRenderingContext rendCtx(&aContext);
while (run.mFrame) {
nsTextFrame* frame = run.mFrame;
// Determine how much of the left and right edges of the text frame we
// need to ignore.
SVGCharClipDisplayItem item(run);
// Set up the fill and stroke so that SVG glyphs can get painted correctly
@@ -3680,23 +3679,23 @@ SVGTextFrame::PaintSVG(gfxContext& aCont
// indicated by the run.
gfxMatrix runTransform =
run.GetTransformFromUserSpaceForPainting(presContext, item) *
currentMatrix;
aContext.SetMatrix(runTransform);
if (drawMode != DrawMode(0)) {
bool paintSVGGlyphs;
- nsTextFrame::PaintTextParams params(rendCtx.ThebesContext());
+ nsTextFrame::PaintTextParams params(&aContext);
params.framePt = gfxPoint();
params.dirtyRect = LayoutDevicePixel::
FromAppUnits(frame->GetVisualOverflowRect(), auPerDevPx);
params.contextPaint = contextPaint;
if (ShouldRenderAsPath(frame, paintSVGGlyphs)) {
- SVGTextDrawPathCallbacks callbacks(&rendCtx, frame,
+ SVGTextDrawPathCallbacks callbacks(&aContext, frame,
matrixForPaintServers,
paintSVGGlyphs);
params.callbacks = &callbacks;
frame->PaintText(params, item);
} else {
frame->PaintText(params, item);
}
}
@@ -5303,31 +5302,31 @@ SVGTextFrame::DoReflow()
mState &= ~(NS_FRAME_IS_DIRTY | NS_FRAME_HAS_DIRTY_CHILDREN);
}
nsPresContext *presContext = PresContext();
nsIFrame* kid = PrincipalChildList().FirstChild();
if (!kid)
return;
- nsRenderingContext renderingContext(
- presContext->PresShell()->CreateReferenceRenderingContext());
+ RefPtr<gfxContext> renderingContext =
+ presContext->PresShell()->CreateReferenceRenderingContext();
if (UpdateFontSizeScaleFactor()) {
// If the font size scale factor changed, we need the block to report
// an updated preferred width.
kid->MarkIntrinsicISizesDirty();
}
mState |= NS_STATE_SVG_TEXT_IN_REFLOW;
- nscoord inlineSize = kid->GetPrefISize(&renderingContext);
+ nscoord inlineSize = kid->GetPrefISize(renderingContext);
WritingMode wm = kid->GetWritingMode();
ReflowInput reflowInput(presContext, kid,
- &renderingContext,
+ renderingContext,
LogicalSize(wm, inlineSize,
NS_UNCONSTRAINEDSIZE));
ReflowOutput desiredSize(reflowInput);
nsReflowStatus status;
NS_ASSERTION(reflowInput.ComputedPhysicalBorderPadding() == nsMargin(0, 0, 0, 0) &&
reflowInput.ComputedPhysicalMargin() == nsMargin(0, 0, 0, 0),
"style system should ensure that :-moz-svg-text "
--- a/layout/svg/nsCSSClipPathInstance.cpp
+++ b/layout/svg/nsCSSClipPathInstance.cpp
@@ -2,25 +2,25 @@
/* 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/. */
// Main header first:
#include "nsCSSClipPathInstance.h"
#include "gfx2DGlue.h"
+#include "gfxContext.h"
#include "gfxPlatform.h"
#include "mozilla/dom/SVGSVGElement.h"
#include "mozilla/gfx/2D.h"
#include "mozilla/gfx/PathHelpers.h"
#include "mozilla/ShapeUtils.h"
#include "nsCSSRendering.h"
#include "nsIFrame.h"
#include "nsLayoutUtils.h"
-#include "nsRenderingContext.h"
#include "nsRuleNode.h"
#include "nsSVGElement.h"
#include "nsSVGUtils.h"
#include "nsSVGViewBox.h"
using namespace mozilla;
using namespace mozilla::dom;
using namespace mozilla::gfx;
--- a/layout/svg/nsCSSClipPathInstance.h
+++ b/layout/svg/nsCSSClipPathInstance.h
@@ -6,17 +6,17 @@
#ifndef __NS_CSSCLIPPATHINSTANCE_H__
#define __NS_CSSCLIPPATHINSTANCE_H__
#include "nsStyleStruct.h"
#include "nsRect.h"
#include "mozilla/gfx/2D.h"
class nsIFrame;
-class nsRenderingContext;
+class gfxContext;
namespace mozilla {
class nsCSSClipPathInstance
{
typedef mozilla::gfx::DrawTarget DrawTarget;
typedef mozilla::gfx::Path Path;
--- a/layout/svg/nsSVGForeignObjectFrame.cpp
+++ b/layout/svg/nsSVGForeignObjectFrame.cpp
@@ -9,17 +9,16 @@
// Keep others in (case-insensitive) order:
#include "DrawResult.h"
#include "gfxContext.h"
#include "nsDisplayList.h"
#include "nsGkAtoms.h"
#include "nsNameSpaceManager.h"
#include "nsLayoutUtils.h"
#include "nsRegion.h"
-#include "nsRenderingContext.h"
#include "nsSVGContainerFrame.h"
#include "nsSVGEffects.h"
#include "mozilla/dom/SVGForeignObjectElement.h"
#include "nsSVGIntegrationUtils.h"
#include "nsSVGOuterSVGFrame.h"
#include "nsSVGUtils.h"
#include "mozilla/AutoRestore.h"
@@ -274,18 +273,17 @@ nsSVGForeignObjectFrame::PaintSVG(gfxCon
using PaintFrameFlags = nsLayoutUtils::PaintFrameFlags;
PaintFrameFlags flags = PaintFrameFlags::PAINT_IN_TRANSFORM;
if (SVGAutoRenderState::IsPaintingToWindow(aContext.GetDrawTarget())) {
flags |= PaintFrameFlags::PAINT_TO_WINDOW;
}
if (aImgParams.imageFlags & imgIContainer::FLAG_SYNC_DECODE) {
flags |= PaintFrameFlags::PAINT_SYNC_DECODE_IMAGES;
}
- nsRenderingContext rendCtx(&aContext);
- Unused << nsLayoutUtils::PaintFrame(&rendCtx, kid, nsRegion(kidDirtyRect),
+ Unused << nsLayoutUtils::PaintFrame(&aContext, kid, nsRegion(kidDirtyRect),
NS_RGBA(0,0,0,0),
nsDisplayListBuilderMode::PAINTING,
flags);
aContext.Restore();
}
nsIFrame*
@@ -518,24 +516,24 @@ nsSVGForeignObjectFrame::DoReflow()
return;
nsPresContext *presContext = PresContext();
nsIFrame* kid = PrincipalChildList().FirstChild();
if (!kid)
return;
// initiate a synchronous reflow here and now:
- nsRenderingContext renderingContext(
- presContext->PresShell()->CreateReferenceRenderingContext());
+ RefPtr<gfxContext> renderingContext =
+ presContext->PresShell()->CreateReferenceRenderingContext();
mInReflow = true;
WritingMode wm = kid->GetWritingMode();
ReflowInput reflowInput(presContext, kid,
- &renderingContext,
+ renderingContext,
LogicalSize(wm, ISize(wm),
NS_UNCONSTRAINEDSIZE));
ReflowOutput desiredSize(reflowInput);
nsReflowStatus status;
// We don't use mRect.height above because that tells the child to do
// page/column breaking at that height.
NS_ASSERTION(reflowInput.ComputedPhysicalBorderPadding() == nsMargin(0, 0, 0, 0) &&
--- a/layout/svg/nsSVGIntegrationUtils.cpp
+++ b/layout/svg/nsSVGIntegrationUtils.cpp
@@ -9,17 +9,17 @@
// Keep others in (case-insensitive) order:
#include "gfxDrawable.h"
#include "gfxPrefs.h"
#include "nsCSSAnonBoxes.h"
#include "nsCSSClipPathInstance.h"
#include "nsDisplayList.h"
#include "nsFilterInstance.h"
#include "nsLayoutUtils.h"
-#include "nsRenderingContext.h"
+#include "gfxContext.h"
#include "nsSVGClipPathFrame.h"
#include "nsSVGEffects.h"
#include "nsSVGElement.h"
#include "nsSVGFilterPaintCallback.h"
#include "nsSVGMaskFrame.h"
#include "nsSVGPaintServerFrame.h"
#include "nsSVGUtils.h"
#include "FrameLayerBuilder.h"
@@ -460,29 +460,28 @@ PaintMaskSurface(const PaintFramesParams
aMaskDT->MaskSurface(ColorPattern(Color(0.0, 0.0, 0.0, 1.0)), svgMask,
Point(0, 0),
DrawOptions(1.0, compositionOp));
}
} else {
gfxContextMatrixAutoSaveRestore matRestore(maskContext);
maskContext->Multiply(gfxMatrix::Translation(-devPixelOffsetToUserSpace));
- nsRenderingContext rc(maskContext);
nsCSSRendering::PaintBGParams params =
nsCSSRendering::PaintBGParams::ForSingleLayer(*presContext,
aParams.dirtyRect,
aParams.borderArea,
aParams.frame,
aParams.builder->GetBackgroundPaintFlags() |
nsCSSRendering::PAINTBG_MASK_IMAGE,
i, compositionOp,
aOpacity);
aParams.imgParams.result &=
- nsCSSRendering::PaintStyleImageLayerWithSC(params, rc, aSC,
+ nsCSSRendering::PaintStyleImageLayerWithSC(params, *maskContext, aSC,
*aParams.frame->StyleBorder());
}
}
}
struct MaskPaintResult {
RefPtr<SourceSurface> maskSurface;
Matrix maskTransform;
@@ -1162,33 +1161,32 @@ PaintFrameCallback::operator()(gfxContex
nsRect dirty(-offset.x, -offset.y,
mPaintServerSize.width, mPaintServerSize.height);
using PaintFrameFlags = nsLayoutUtils::PaintFrameFlags;
PaintFrameFlags flags = PaintFrameFlags::PAINT_IN_TRANSFORM;
if (mFlags & nsSVGIntegrationUtils::FLAG_SYNC_DECODE_IMAGES) {
flags |= PaintFrameFlags::PAINT_SYNC_DECODE_IMAGES;
}
- nsRenderingContext context(aContext);
- nsLayoutUtils::PaintFrame(&context, mFrame,
+ nsLayoutUtils::PaintFrame(aContext, mFrame,
dirty, NS_RGBA(0, 0, 0, 0),
nsDisplayListBuilderMode::PAINTING,
flags);
nsIFrame* currentFrame = mFrame;
while ((currentFrame = currentFrame->GetNextContinuation()) != nullptr) {
offset = currentFrame->GetOffsetToCrossDoc(mFrame);
devPxOffset = gfxPoint(offset.x, offset.y) / appUnitsPerDevPixel;
aContext->Save();
aContext->Multiply(gfxMatrix::Scaling(1/scaleX, 1/scaleY));
aContext->Multiply(gfxMatrix::Translation(devPxOffset));
aContext->Multiply(gfxMatrix::Scaling(scaleX, scaleY));
- nsLayoutUtils::PaintFrame(&context, currentFrame,
+ nsLayoutUtils::PaintFrame(aContext, currentFrame,
dirty - offset, NS_RGBA(0, 0, 0, 0),
nsDisplayListBuilderMode::PAINTING,
flags);
aContext->Restore();
}
aContext->Restore();
--- a/layout/svg/nsSVGOuterSVGFrame.cpp
+++ b/layout/svg/nsSVGOuterSVGFrame.cpp
@@ -2,22 +2,22 @@
/* 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/. */
// Main header first:
#include "nsSVGOuterSVGFrame.h"
// Keep others in (case-insensitive) order:
+#include "gfxContext.h"
#include "nsDisplayList.h"
#include "nsIDocument.h"
#include "nsIDOMHTMLIFrameElement.h"
#include "nsIInterfaceRequestorUtils.h"
#include "nsIObjectLoadingContent.h"
-#include "nsRenderingContext.h"
#include "nsSVGIntegrationUtils.h"
#include "nsSVGForeignObjectFrame.h"
#include "mozilla/dom/SVGSVGElement.h"
#include "mozilla/dom/SVGViewElement.h"
#include "nsSubDocumentFrame.h"
using namespace mozilla;
using namespace mozilla::dom;
@@ -147,28 +147,28 @@ NS_QUERYFRAME_HEAD(nsSVGOuterSVGFrame)
NS_QUERYFRAME_TAIL_INHERITING(nsSVGDisplayContainerFrame)
//----------------------------------------------------------------------
// nsIFrame methods
//----------------------------------------------------------------------
// reflowing
/* virtual */ nscoord
-nsSVGOuterSVGFrame::GetMinISize(nsRenderingContext *aRenderingContext)
+nsSVGOuterSVGFrame::GetMinISize(gfxContext *aRenderingContext)
{
nscoord result;
DISPLAY_MIN_WIDTH(this, result);
result = nscoord(0);
return result;
}
/* virtual */ nscoord
-nsSVGOuterSVGFrame::GetPrefISize(nsRenderingContext *aRenderingContext)
+nsSVGOuterSVGFrame::GetPrefISize(gfxContext *aRenderingContext)
{
nscoord result;
DISPLAY_PREF_WIDTH(this, result);
SVGSVGElement *svg = static_cast<SVGSVGElement*>(mContent);
WritingMode wm = GetWritingMode();
const nsSVGLength2& isize = wm.IsVertical()
? svg->mLengthAttributes[SVGSVGElement::ATTR_HEIGHT]
@@ -278,17 +278,17 @@ nsSVGOuterSVGFrame::GetIntrinsicRatio()
NSToCoordRoundWithClamp(viewBoxHeight));
}
return nsSVGDisplayContainerFrame::GetIntrinsicRatio();
}
/* virtual */
LogicalSize
-nsSVGOuterSVGFrame::ComputeSize(nsRenderingContext *aRenderingContext,
+nsSVGOuterSVGFrame::ComputeSize(gfxContext *aRenderingContext,
WritingMode aWM,
const LogicalSize& aCBSize,
nscoord aAvailableISize,
const LogicalSize& aMargin,
const LogicalSize& aBorder,
const LogicalSize& aPadding,
ComputeSizeFlags aFlags)
{
@@ -548,17 +548,17 @@ public:
MOZ_COUNT_DTOR(nsDisplayOuterSVG);
}
#endif
virtual void HitTest(nsDisplayListBuilder* aBuilder, const nsRect& aRect,
HitTestState* aState,
nsTArray<nsIFrame*> *aOutFrames) override;
virtual void Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) override;
+ gfxContext* aCtx) override;
virtual void ComputeInvalidationRegion(nsDisplayListBuilder* aBuilder,
const nsDisplayItemGeometry* aGeometry,
nsRegion* aInvalidRegion) override;
nsDisplayItemGeometry* AllocateGeometry(nsDisplayListBuilder* aBuilder) override
{
return new nsDisplayItemGenericImageGeometry(this, aBuilder);
@@ -592,17 +592,17 @@ nsDisplayOuterSVG::HitTest(nsDisplayList
nsSVGUtils::HitTestChildren(anonKid, svgViewportRelativePoint);
if (frame) {
aOutFrames->AppendElement(frame);
}
}
void
nsDisplayOuterSVG::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aContext)
+ gfxContext* aContext)
{
#if defined(DEBUG) && defined(SVG_DEBUG_PAINT_TIMING)
PRTime start = PR_Now();
#endif
// Create an SVGAutoRenderState so we can call SetPaintingToWindow on it.
SVGAutoRenderState state(aContext->GetDrawTarget());
@@ -619,28 +619,28 @@ nsDisplayOuterSVG::Paint(nsDisplayListBu
nsIntRect contentAreaDirtyRect =
(clipRect - viewportRect.TopLeft()).
ToOutsidePixels(appUnitsPerDevPixel);
gfxPoint devPixelOffset =
nsLayoutUtils::PointToGfxPoint(viewportRect.TopLeft(), appUnitsPerDevPixel);
- aContext->ThebesContext()->Save();
+ aContext->Save();
imgDrawingParams imgParams(aBuilder->ShouldSyncDecodeImages()
? imgIContainer::FLAG_SYNC_DECODE
: imgIContainer::FLAG_SYNC_DECODE_IF_FAST);
// We include the offset of our frame and a scale from device pixels to user
// units (i.e. CSS px) in the matrix that we pass to our children):
gfxMatrix tm = nsSVGUtils::GetCSSPxToDevPxMatrix(mFrame) *
gfxMatrix::Translation(devPixelOffset);
- nsSVGUtils::PaintFrameWithEffects(mFrame, *aContext->ThebesContext(), tm,
+ nsSVGUtils::PaintFrameWithEffects(mFrame, *aContext, tm,
imgParams, &contentAreaDirtyRect);
nsDisplayItemGenericImageGeometry::UpdateDrawResult(this, imgParams.result);
- aContext->ThebesContext()->Restore();
+ aContext->Restore();
#if defined(DEBUG) && defined(SVG_DEBUG_PAINT_TIMING)
PRTime end = PR_Now();
printf("SVG Paint Timing: %f ms\n", (end-start)/1000.0);
#endif
}
nsRegion
--- a/layout/svg/nsSVGOuterSVGFrame.h
+++ b/layout/svg/nsSVGOuterSVGFrame.h
@@ -35,24 +35,24 @@ public:
#ifdef DEBUG
~nsSVGOuterSVGFrame() {
NS_ASSERTION(!mForeignObjectHash || mForeignObjectHash->Count() == 0,
"foreignObject(s) still registered!");
}
#endif
// nsIFrame:
- virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override;
- virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override;
+ virtual nscoord GetMinISize(gfxContext *aRenderingContext) override;
+ virtual nscoord GetPrefISize(gfxContext *aRenderingContext) override;
virtual mozilla::IntrinsicSize GetIntrinsicSize() override;
virtual nsSize GetIntrinsicRatio() override;
virtual mozilla::LogicalSize
- ComputeSize(nsRenderingContext *aRenderingContext,
+ ComputeSize(gfxContext *aRenderingContext,
mozilla::WritingMode aWritingMode,
const mozilla::LogicalSize& aCBSize,
nscoord aAvailableISize,
const mozilla::LogicalSize& aMargin,
const mozilla::LogicalSize& aBorder,
const mozilla::LogicalSize& aPadding,
ComputeSizeFlags aFlags) override;
--- a/layout/tables/BasicTableLayoutStrategy.cpp
+++ b/layout/tables/BasicTableLayoutStrategy.cpp
@@ -36,27 +36,27 @@ BasicTableLayoutStrategy::BasicTableLayo
}
/* virtual */
BasicTableLayoutStrategy::~BasicTableLayoutStrategy()
{
}
/* virtual */ nscoord
-BasicTableLayoutStrategy::GetMinISize(nsRenderingContext* aRenderingContext)
+BasicTableLayoutStrategy::GetMinISize(gfxContext* aRenderingContext)
{
DISPLAY_MIN_WIDTH(mTableFrame, mMinISize);
if (mMinISize == NS_INTRINSIC_WIDTH_UNKNOWN) {
ComputeIntrinsicISizes(aRenderingContext);
}
return mMinISize;
}
/* virtual */ nscoord
-BasicTableLayoutStrategy::GetPrefISize(nsRenderingContext* aRenderingContext,
+BasicTableLayoutStrategy::GetPrefISize(gfxContext* aRenderingContext,
bool aComputingSize)
{
DISPLAY_PREF_WIDTH(mTableFrame, mPrefISize);
NS_ASSERTION((mPrefISize == NS_INTRINSIC_WIDTH_UNKNOWN) ==
(mPrefISizePctExpand == NS_INTRINSIC_WIDTH_UNKNOWN),
"dirtyness out of sync");
if (mPrefISize == NS_INTRINSIC_WIDTH_UNKNOWN) {
ComputeIntrinsicISizes(aRenderingContext);
@@ -78,17 +78,17 @@ struct CellISizeInfo {
nscoord minCoord;
nscoord prefCoord;
float prefPercent;
};
// Used for both column and cell calculations. The parts needed only
// for cells are skipped when aIsCell is false.
static CellISizeInfo
-GetISizeInfo(nsRenderingContext *aRenderingContext,
+GetISizeInfo(gfxContext *aRenderingContext,
nsIFrame *aFrame, WritingMode aWM, bool aIsCell)
{
nscoord minCoord, prefCoord;
const nsStylePosition *stylePos = aFrame->StylePosition();
bool isQuirks = aFrame->PresContext()->CompatibilityMode() ==
eCompatibility_NavQuirks;
nscoord boxSizingToBorderEdge = 0;
if (aIsCell) {
@@ -232,38 +232,38 @@ GetISizeInfo(nsRenderingContext *aRender
minCoord += boxSizingToBorderEdge;
prefCoord = NSCoordSaturatingAdd(prefCoord, boxSizingToBorderEdge);
}
return CellISizeInfo(minCoord, prefCoord, prefPercent, hasSpecifiedISize);
}
static inline CellISizeInfo
-GetCellISizeInfo(nsRenderingContext *aRenderingContext,
+GetCellISizeInfo(gfxContext *aRenderingContext,
nsTableCellFrame *aCellFrame, WritingMode aWM)
{
return GetISizeInfo(aRenderingContext, aCellFrame, aWM, true);
}
static inline CellISizeInfo
-GetColISizeInfo(nsRenderingContext *aRenderingContext,
+GetColISizeInfo(gfxContext *aRenderingContext,
nsIFrame *aFrame, WritingMode aWM)
{
return GetISizeInfo(aRenderingContext, aFrame, aWM, false);
}
/**
* The algorithm in this function, in addition to meeting the
* requirements of Web-compatibility, is also invariant under reordering
* of the rows within a table (something that most, but not all, other
* browsers are).
*/
void
-BasicTableLayoutStrategy::ComputeColumnIntrinsicISizes(nsRenderingContext* aRenderingContext)
+BasicTableLayoutStrategy::ComputeColumnIntrinsicISizes(gfxContext* aRenderingContext)
{
nsTableFrame *tableFrame = mTableFrame;
nsTableCellMap *cellMap = tableFrame->GetCellMap();
WritingMode wm = tableFrame->GetWritingMode();
mozilla::AutoStackArena arena;
SpanningCellSorter spanningCells;
@@ -418,17 +418,17 @@ BasicTableLayoutStrategy::ComputeColumnI
#ifdef DEBUG_TABLE_STRATEGY
printf("ComputeColumnIntrinsicISizes spanning\n");
mTableFrame->Dump(false, true, false);
#endif
}
void
-BasicTableLayoutStrategy::ComputeIntrinsicISizes(nsRenderingContext* aRenderingContext)
+BasicTableLayoutStrategy::ComputeIntrinsicISizes(gfxContext* aRenderingContext)
{
ComputeColumnIntrinsicISizes(aRenderingContext);
nsTableCellMap *cellMap = mTableFrame->GetCellMap();
nscoord min = 0, pref = 0, max_small_pct_pref = 0, nonpct_pref_total = 0;
float pct_total = 0.0f; // always from 0.0f - 1.0f
int32_t colCount = cellMap->GetColCount();
// add a total of (colcount + 1) lots of cellSpacingX for columns where a
--- a/layout/tables/BasicTableLayoutStrategy.h
+++ b/layout/tables/BasicTableLayoutStrategy.h
@@ -19,31 +19,31 @@ class nsTableFrame;
class BasicTableLayoutStrategy : public nsITableLayoutStrategy
{
public:
explicit BasicTableLayoutStrategy(nsTableFrame *aTableFrame);
virtual ~BasicTableLayoutStrategy();
// nsITableLayoutStrategy implementation
- virtual nscoord GetMinISize(nsRenderingContext* aRenderingContext) override;
- virtual nscoord GetPrefISize(nsRenderingContext* aRenderingContext,
+ virtual nscoord GetMinISize(gfxContext* aRenderingContext) override;
+ virtual nscoord GetPrefISize(gfxContext* aRenderingContext,
bool aComputingSize) override;
virtual void MarkIntrinsicISizesDirty() override;
virtual void ComputeColumnISizes(const ReflowInput& aReflowInput) override;
private:
// NOTE: Using prefix "BTLS" to avoid overlapping names with
// the values of nsLayoutUtils::IntrinsicISizeType
enum BtlsISizeType { BTLS_MIN_ISIZE,
BTLS_PREF_ISIZE,
BTLS_FINAL_ISIZE };
// Compute intrinsic isize member variables on the columns.
- void ComputeColumnIntrinsicISizes(nsRenderingContext* aRenderingContext);
+ void ComputeColumnIntrinsicISizes(gfxContext* aRenderingContext);
// Distribute a colspanning cell's percent isize (if any) to its columns.
void DistributePctISizeToColumns(float aSpanPrefPct,
int32_t aFirstCol,
int32_t aColCount);
// Distribute an isize of some BltsISizeType type to a set of columns.
// aISize: The amount of isize to be distributed
@@ -64,17 +64,17 @@ private:
int32_t aFirstCol,
int32_t aColCount,
BtlsISizeType aISizeType,
bool aSpanHasSpecifiedISize);
// Compute the min and pref isizes of the table from the isize
// variables on the columns.
- void ComputeIntrinsicISizes(nsRenderingContext* aRenderingContext);
+ void ComputeIntrinsicISizes(gfxContext* aRenderingContext);
nsTableFrame *mTableFrame;
nscoord mMinISize;
nscoord mPrefISize;
nscoord mPrefISizePctExpand;
nscoord mLastCalcISize;
};
--- a/layout/tables/FixedTableLayoutStrategy.cpp
+++ b/layout/tables/FixedTableLayoutStrategy.cpp
@@ -23,17 +23,17 @@ FixedTableLayoutStrategy::FixedTableLayo
}
/* virtual */
FixedTableLayoutStrategy::~FixedTableLayoutStrategy()
{
}
/* virtual */ nscoord
-FixedTableLayoutStrategy::GetMinISize(nsRenderingContext* aRenderingContext)
+FixedTableLayoutStrategy::GetMinISize(gfxContext* aRenderingContext)
{
DISPLAY_MIN_WIDTH(mTableFrame, mMinISize);
if (mMinISize != NS_INTRINSIC_WIDTH_UNKNOWN) {
return mMinISize;
}
// It's theoretically possible to do something much better here that
// depends only on the columns and the first row (where we look at
@@ -113,17 +113,17 @@ FixedTableLayoutStrategy::GetMinISize(ns
}
}
}
return (mMinISize = result);
}
/* virtual */ nscoord
-FixedTableLayoutStrategy::GetPrefISize(nsRenderingContext* aRenderingContext,
+FixedTableLayoutStrategy::GetPrefISize(gfxContext* aRenderingContext,
bool aComputingSize)
{
// It's theoretically possible to do something much better here that
// depends only on the columns and the first row (where we look at
// intrinsic inline sizes inside the first row and then reverse the
// algorithm to find the narrowest inline size that would hold all of
// those intrinsic inline sizes), but it wouldn't be compatible with
// other browsers.
--- a/layout/tables/FixedTableLayoutStrategy.h
+++ b/layout/tables/FixedTableLayoutStrategy.h
@@ -19,18 +19,18 @@ class nsTableFrame;
class FixedTableLayoutStrategy : public nsITableLayoutStrategy
{
public:
explicit FixedTableLayoutStrategy(nsTableFrame *aTableFrame);
virtual ~FixedTableLayoutStrategy();
// nsITableLayoutStrategy implementation
- virtual nscoord GetMinISize(nsRenderingContext* aRenderingContext) override;
- virtual nscoord GetPrefISize(nsRenderingContext* aRenderingContext,
+ virtual nscoord GetMinISize(gfxContext* aRenderingContext) override;
+ virtual nscoord GetPrefISize(gfxContext* aRenderingContext,
bool aComputingSize) override;
virtual void MarkIntrinsicISizesDirty() override;
virtual void ComputeColumnISizes(const ReflowInput& aReflowInput)
override;
private:
nsTableFrame *mTableFrame;
nscoord mMinISize;
--- a/layout/tables/nsITableLayoutStrategy.h
+++ b/layout/tables/nsITableLayoutStrategy.h
@@ -10,33 +10,33 @@
*/
#ifndef nsITableLayoutStrategy_h_
#define nsITableLayoutStrategy_h_
#include "nscore.h"
#include "nsCoord.h"
-class nsRenderingContext;
+class gfxContext;
namespace mozilla {
struct ReflowInput;
} // namespace mozilla
class nsITableLayoutStrategy
{
public:
using ReflowInput = mozilla::ReflowInput;
virtual ~nsITableLayoutStrategy() {}
/** Implement nsIFrame::GetMinISize for the table */
- virtual nscoord GetMinISize(nsRenderingContext* aRenderingContext) = 0;
+ virtual nscoord GetMinISize(gfxContext* aRenderingContext) = 0;
/** Implement nsIFrame::GetPrefISize for the table */
- virtual nscoord GetPrefISize(nsRenderingContext* aRenderingContext,
+ virtual nscoord GetPrefISize(gfxContext* aRenderingContext,
bool aComputingSize) = 0;
/** Implement nsIFrame::MarkIntrinsicISizesDirty for the table */
virtual void MarkIntrinsicISizesDirty() = 0;
/**
* Compute final column isizes based on the intrinsic isize data and
* the available isize.
--- a/layout/tables/nsTableCellFrame.cpp
+++ b/layout/tables/nsTableCellFrame.cpp
@@ -1,26 +1,26 @@
/* -*- 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 "nsTableCellFrame.h"
+#include "gfxContext.h"
#include "gfxUtils.h"
#include "mozilla/gfx/2D.h"
#include "mozilla/gfx/Helpers.h"
#include "nsTableFrame.h"
#include "nsTableColFrame.h"
#include "nsTableRowFrame.h"
#include "nsTableRowGroupFrame.h"
#include "nsStyleContext.h"
#include "nsStyleConsts.h"
#include "nsPresContext.h"
-#include "nsRenderingContext.h"
#include "nsCSSRendering.h"
#include "nsIContent.h"
#include "nsGenericHTMLElement.h"
#include "nsAttrValueInlines.h"
#include "nsHTMLParts.h"
#include "nsGkAtoms.h"
#include "nsIPresShell.h"
#include "nsCOMPtr.h"
@@ -367,17 +367,17 @@ nsTableCellFrame::DecorateForSelection(D
nsPoint(mRect.width - (2*onePixel), mRect.height-onePixel),
appUnitsPerDevPixel, *aDrawTarget, color);
}
}
}
}
DrawResult
-nsTableCellFrame::PaintBackground(nsRenderingContext& aRenderingContext,
+nsTableCellFrame::PaintBackground(gfxContext& aRenderingContext,
const nsRect& aDirtyRect,
nsPoint aPt,
uint32_t aFlags)
{
nsRect rect(aPt, GetSize());
nsCSSRendering::PaintBGParams params =
nsCSSRendering::PaintBGParams::ForAllLayers(*PresContext(),
aDirtyRect, rect,
@@ -417,24 +417,24 @@ public:
#endif
virtual void HitTest(nsDisplayListBuilder* aBuilder, const nsRect& aRect,
HitTestState* aState,
nsTArray<nsIFrame*> *aOutFrames) override {
aOutFrames->AppendElement(mFrame);
}
virtual void Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) override;
+ gfxContext* aCtx) override;
virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder,
bool* aSnap) override;
NS_DISPLAY_DECL_NAME("TableCellBackground", TYPE_TABLE_CELL_BACKGROUND)
};
void nsDisplayTableCellBackground::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx)
+ gfxContext* aCtx)
{
DrawResult result = static_cast<nsTableCellFrame*>(mFrame)->
PaintBackground(*aCtx, mVisibleRect, ToReferenceFrame(),
aBuilder->GetBackgroundPaintFlags());
nsDisplayTableItemGeometry::UpdateDrawResult(this, result);
}
@@ -739,29 +739,29 @@ int32_t nsTableCellFrame::GetColSpan()
if (attr && attr->Type() == nsAttrValue::eInteger) {
colSpan = attr->GetIntegerValue();
}
}
return colSpan;
}
/* virtual */ nscoord
-nsTableCellFrame::GetMinISize(nsRenderingContext *aRenderingContext)
+nsTableCellFrame::GetMinISize(gfxContext *aRenderingContext)
{
nscoord result = 0;
DISPLAY_MIN_WIDTH(this, result);
nsIFrame *inner = mFrames.FirstChild();
result = nsLayoutUtils::IntrinsicForContainer(aRenderingContext, inner,
nsLayoutUtils::MIN_ISIZE);
return result;
}
/* virtual */ nscoord
-nsTableCellFrame::GetPrefISize(nsRenderingContext *aRenderingContext)
+nsTableCellFrame::GetPrefISize(gfxContext *aRenderingContext)
{
nscoord result = 0;
DISPLAY_PREF_WIDTH(this, result);
nsIFrame *inner = mFrames.FirstChild();
result = nsLayoutUtils::IntrinsicForContainer(aRenderingContext, inner,
nsLayoutUtils::PREF_ISIZE);
return result;
@@ -1175,17 +1175,17 @@ nsBCTableCellFrame::GetBorderOverflow()
BC_BORDER_START_HALF_COORD(p2t, mBStartBorder),
BC_BORDER_END_HALF_COORD(p2t, mIEndBorder),
BC_BORDER_END_HALF_COORD(p2t, mBEndBorder),
BC_BORDER_START_HALF_COORD(p2t, mIStartBorder));
return halfBorder.GetPhysicalMargin(wm);
}
DrawResult
-nsBCTableCellFrame::PaintBackground(nsRenderingContext& aRenderingContext,
+nsBCTableCellFrame::PaintBackground(gfxContext& aRenderingContext,
const nsRect& aDirtyRect,
nsPoint aPt,
uint32_t aFlags)
{
// make border-width reflect the half of the border-collapse
// assigned border that's inside the cell
WritingMode wm = GetWritingMode();
nsMargin borderWidth = GetBorderWidth(wm).GetPhysicalMargin(wm);
--- a/layout/tables/nsTableCellFrame.h
+++ b/layout/tables/nsTableCellFrame.h
@@ -107,18 +107,18 @@ public:
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) override;
virtual nsresult ProcessBorders(nsTableFrame* aFrame,
nsDisplayListBuilder* aBuilder,
const nsDisplayListSet& aLists);
- virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override;
- virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override;
+ virtual nscoord GetMinISize(gfxContext *aRenderingContext) override;
+ virtual nscoord GetPrefISize(gfxContext *aRenderingContext) override;
virtual IntrinsicISizeOffsetData IntrinsicISizeOffsets() override;
virtual void Reflow(nsPresContext* aPresContext,
ReflowOutput& aDesiredSize,
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus) override;
#ifdef DEBUG_FRAME_DUMP
@@ -205,17 +205,17 @@ public:
bool HasPctOverBSize();
void SetHasPctOverBSize(bool aValue);
nsTableCellFrame* GetNextCell() const;
virtual LogicalMargin GetBorderWidth(WritingMode aWM) const;
- virtual DrawResult PaintBackground(nsRenderingContext& aRenderingContext,
+ virtual DrawResult PaintBackground(gfxContext& aRenderingContext,
const nsRect& aDirtyRect,
nsPoint aPt,
uint32_t aFlags);
void DecorateForSelection(DrawTarget* aDrawTarget, nsPoint aPt);
virtual bool ComputeCustomOverflow(nsOverflowAreas& aOverflowAreas) override;
@@ -323,17 +323,17 @@ public:
void SetBorderWidth(LogicalSide aSide, BCPixelSize aPixelValue);
virtual nsMargin GetBorderOverflow() override;
#ifdef DEBUG_FRAME_DUMP
virtual nsresult GetFrameName(nsAString& aResult) const override;
#endif
- virtual DrawResult PaintBackground(nsRenderingContext& aRenderingContext,
+ virtual DrawResult PaintBackground(gfxContext& aRenderingContext,
const nsRect& aDirtyRect,
nsPoint aPt,
uint32_t aFlags) override;
private:
// These are the entire width of the border (the cell edge contains only
// the inner half, per the macros in nsTablePainter.h).
--- a/layout/tables/nsTableFrame.cpp
+++ b/layout/tables/nsTableFrame.cpp
@@ -4,19 +4,19 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "mozilla/Likely.h"
#include "mozilla/MathAlgorithms.h"
#include "mozilla/IntegerRange.h"
#include "mozilla/WritingModes.h"
+#include "gfxContext.h"
#include "nsCOMPtr.h"
#include "nsTableFrame.h"
-#include "nsRenderingContext.h"
#include "nsStyleContext.h"
#include "nsStyleConsts.h"
#include "nsIContent.h"
#include "nsCellMap.h"
#include "nsTableCellFrame.h"
#include "nsHTMLParts.h"
#include "nsTableColFrame.h"
#include "nsTableColGroupFrame.h"
@@ -1266,33 +1266,33 @@ public:
}
#ifdef NS_BUILD_REFCNT_LOGGING
virtual ~nsDisplayTableBorderCollapse() {
MOZ_COUNT_DTOR(nsDisplayTableBorderCollapse);
}
#endif
virtual void Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) override;
+ gfxContext* aCtx) override;
virtual already_AddRefed<layers::Layer> BuildLayer(nsDisplayListBuilder* aBuilder,
LayerManager* aManager,
const ContainerLayerParameters& aContainerParameters) override;
virtual void CreateWebRenderCommands(mozilla::wr::DisplayListBuilder& aBuilder,
const StackingContextHelper& aSc,
nsTArray<WebRenderParentCommand>& aParentCommands,
WebRenderDisplayItemLayer* aLayer) override;
virtual LayerState GetLayerState(nsDisplayListBuilder* aBuilder,
LayerManager* aManager,
const ContainerLayerParameters& aParameters) override;
NS_DISPLAY_DECL_NAME("TableBorderCollapse", TYPE_TABLE_BORDER_COLLAPSE)
};
void
nsDisplayTableBorderCollapse::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx)
+ gfxContext* aCtx)
{
nsPoint pt = ToReferenceFrame();
DrawTarget* drawTarget = aCtx->GetDrawTarget();
gfxPoint devPixelOffset =
nsLayoutUtils::PointToGfxPoint(pt, mFrame->PresContext()->AppUnitsPerDevPixel());
// XXX we should probably get rid of this translation at some stage
@@ -1695,28 +1695,28 @@ nsTableFrame::MarkIntrinsicISizesDirty()
tls->MarkIntrinsicISizesDirty();
// XXXldb Call SetBCDamageArea?
nsContainerFrame::MarkIntrinsicISizesDirty();
}
/* virtual */ nscoord
-nsTableFrame::GetMinISize(nsRenderingContext *aRenderingContext)
+nsTableFrame::GetMinISize(gfxContext *aRenderingContext)
{
if (NeedToCalcBCBorders())
CalcBCBorders();
ReflowColGroups(aRenderingContext);
return LayoutStrategy()->GetMinISize(aRenderingContext);
}
/* virtual */ nscoord
-nsTableFrame::GetPrefISize(nsRenderingContext *aRenderingContext)
+nsTableFrame::GetPrefISize(gfxContext *aRenderingContext)
{
if (NeedToCalcBCBorders())
CalcBCBorders();
ReflowColGroups(aRenderingContext);
return LayoutStrategy()->GetPrefISize(aRenderingContext, false);
}
@@ -1738,17 +1738,17 @@ nsTableFrame::IntrinsicISizeOffsets()
result.hBorder = outerBC.IStartEnd(wm);
}
return result;
}
/* virtual */
LogicalSize
-nsTableFrame::ComputeSize(nsRenderingContext* aRenderingContext,
+nsTableFrame::ComputeSize(gfxContext* aRenderingContext,
WritingMode aWM,
const LogicalSize& aCBSize,
nscoord aAvailableISize,
const LogicalSize& aMargin,
const LogicalSize& aBorder,
const LogicalSize& aPadding,
ComputeSizeFlags aFlags)
{
@@ -1773,17 +1773,17 @@ nsTableFrame::ComputeSize(nsRenderingCon
if (minISize > result.ISize(aWM)) {
result.ISize(aWM) = minISize;
}
return result;
}
nscoord
-nsTableFrame::TableShrinkISizeToFit(nsRenderingContext *aRenderingContext,
+nsTableFrame::TableShrinkISizeToFit(gfxContext *aRenderingContext,
nscoord aISizeInCB)
{
// If we're a container for font size inflation, then shrink
// wrapping inside of us should not apply font size inflation.
AutoMaybeDisableFontInflation an(this);
nscoord result;
nscoord minISize = GetMinISize(aRenderingContext);
@@ -1805,17 +1805,17 @@ nsTableFrame::TableShrinkISizeToFit(nsRe
result = prefISize;
}
}
return result;
}
/* virtual */
LogicalSize
-nsTableFrame::ComputeAutoSize(nsRenderingContext* aRenderingContext,
+nsTableFrame::ComputeAutoSize(gfxContext* aRenderingContext,
WritingMode aWM,
const LogicalSize& aCBSize,
nscoord aAvailableISize,
const LogicalSize& aMargin,
const LogicalSize& aBorder,
const LogicalSize& aPadding,
ComputeSizeFlags aFlags)
{
@@ -3452,17 +3452,17 @@ nsTableFrame::ReflowChildren(TableReflow
// We've now propagated the column resizes and geometry changes to all
// the children.
mBits.mResizedColumns = false;
ClearGeometryDirty();
}
void
-nsTableFrame::ReflowColGroups(nsRenderingContext *aRenderingContext)
+nsTableFrame::ReflowColGroups(gfxContext *aRenderingContext)
{
if (!GetPrevInFlow() && !HaveReflowedColGroups()) {
ReflowOutput kidMet(GetWritingMode());
nsPresContext *presContext = PresContext();
for (nsIFrame* kidFrame : mColGroups) {
if (NS_SUBTREE_DIRTY(kidFrame)) {
// The column groups don't care about dimensions or reflow states.
ReflowInput
--- a/layout/tables/nsTableFrame.h
+++ b/layout/tables/nsTableFrame.h
@@ -309,45 +309,45 @@ public:
const mozilla::layers::StackingContextHelper& aSc,
nsTArray<mozilla::layers::WebRenderParentCommand>& aParentCommands,
mozilla::layers::WebRenderDisplayItemLayer* aLayer,
const nsPoint& aPt);
virtual void MarkIntrinsicISizesDirty() override;
// For border-collapse tables, the caller must not add padding and
// border to the results of these functions.
- virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override;
- virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override;
+ virtual nscoord GetMinISize(gfxContext *aRenderingContext) override;
+ virtual nscoord GetPrefISize(gfxContext *aRenderingContext) override;
virtual IntrinsicISizeOffsetData IntrinsicISizeOffsets() override;
virtual mozilla::LogicalSize
- ComputeSize(nsRenderingContext* aRenderingContext,
+ ComputeSize(gfxContext* aRenderingContext,
mozilla::WritingMode aWM,
const mozilla::LogicalSize& aCBSize,
nscoord aAvailableISize,
const mozilla::LogicalSize& aMargin,
const mozilla::LogicalSize& aBorder,
const mozilla::LogicalSize& aPadding,
ComputeSizeFlags aFlags) override;
virtual mozilla::LogicalSize
- ComputeAutoSize(nsRenderingContext* aRenderingContext,
+ ComputeAutoSize(gfxContext* aRenderingContext,
mozilla::WritingMode aWM,
const mozilla::LogicalSize& aCBSize,
nscoord aAvailableISize,
const mozilla::LogicalSize& aMargin,
const mozilla::LogicalSize& aBorder,
const mozilla::LogicalSize& aPadding,
ComputeSizeFlags aFlags) override;
/**
* A copy of nsFrame::ShrinkWidthToFit that calls a different
* GetPrefISize, since tables have two different ones.
*/
- nscoord TableShrinkISizeToFit(nsRenderingContext *aRenderingContext,
+ nscoord TableShrinkISizeToFit(gfxContext *aRenderingContext,
nscoord aWidthInCB);
// XXXldb REWRITE THIS COMMENT!
/** inner tables are reflowed in two steps.
* <pre>
* if mFirstPassValid is false, this is our first time through since content was last changed
* set pass to 1
* do pass 1
@@ -630,17 +630,17 @@ protected:
void ReflowChildren(TableReflowInput& aReflowInput,
nsReflowStatus& aStatus,
nsIFrame*& aLastChildReflowed,
nsOverflowAreas& aOverflowAreas);
// This calls the col group and column reflow methods, which do two things:
// (1) set all the dimensions to 0
// (2) notify the table about colgroups or columns with hidden visibility
- void ReflowColGroups(nsRenderingContext* aRenderingContext);
+ void ReflowColGroups(gfxContext* aRenderingContext);
/** return the isize of the table taking into account visibility collapse
* on columns and colgroups
* @param aBorderPadding the border and padding of the table
*/
nscoord GetCollapsedISize(const WritingMode aWM,
const LogicalMargin& aBorderPadding);
--- a/layout/tables/nsTableWrapperFrame.cpp
+++ b/layout/tables/nsTableWrapperFrame.cpp
@@ -302,17 +302,17 @@ GetContainingBlockSize(const ReflowInput
if (NS_UNCONSTRAINEDSIZE == size.height) {
size.height = 0;
}
}
return size;
}
/* virtual */ nscoord
-nsTableWrapperFrame::GetMinISize(nsRenderingContext *aRenderingContext)
+nsTableWrapperFrame::GetMinISize(gfxContext *aRenderingContext)
{
nscoord iSize = nsLayoutUtils::IntrinsicForContainer(aRenderingContext,
InnerTableFrame(), nsLayoutUtils::MIN_ISIZE);
DISPLAY_MIN_WIDTH(this, iSize);
if (mCaptionFrames.NotEmpty()) {
nscoord capISize =
nsLayoutUtils::IntrinsicForContainer(aRenderingContext,
mCaptionFrames.FirstChild(),
@@ -324,17 +324,17 @@ nsTableWrapperFrame::GetMinISize(nsRende
iSize = capISize;
}
}
}
return iSize;
}
/* virtual */ nscoord
-nsTableWrapperFrame::GetPrefISize(nsRenderingContext *aRenderingContext)
+nsTableWrapperFrame::GetPrefISize(gfxContext *aRenderingContext)
{
nscoord maxISize;
DISPLAY_PREF_WIDTH(this, maxISize);
maxISize = nsLayoutUtils::IntrinsicForContainer(aRenderingContext,
InnerTableFrame(), nsLayoutUtils::PREF_ISIZE);
if (mCaptionFrames.NotEmpty()) {
uint8_t captionSide = GetCaptionSide();
@@ -371,17 +371,17 @@ nsTableWrapperFrame::GetPrefISize(nsRend
}
break;
}
}
return maxISize;
}
nscoord
-nsTableWrapperFrame::ChildShrinkWrapISize(nsRenderingContext* aRenderingContext,
+nsTableWrapperFrame::ChildShrinkWrapISize(gfxContext* aRenderingContext,
nsIFrame* aChildFrame,
WritingMode aWM,
LogicalSize aCBSize,
nscoord aAvailableISize,
nscoord* aMarginResult) const
{
AutoMaybeDisableFontInflation an(aChildFrame);
@@ -420,17 +420,17 @@ nsTableWrapperFrame::ChildShrinkWrapISiz
if (aMarginResult) {
*aMarginResult = offsets.ComputedLogicalMargin().IStartEnd(aWM);
}
return size.ISize(aWM) + marginSize.ISize(aWM) + bpSize.ISize(aWM);
}
/* virtual */
LogicalSize
-nsTableWrapperFrame::ComputeAutoSize(nsRenderingContext* aRenderingContext,
+nsTableWrapperFrame::ComputeAutoSize(gfxContext* aRenderingContext,
WritingMode aWM,
const LogicalSize& aCBSize,
nscoord aAvailableISize,
const LogicalSize& aMargin,
const LogicalSize& aBorder,
const LogicalSize& aPadding,
ComputeSizeFlags aFlags)
{
--- a/layout/tables/nsTableWrapperFrame.h
+++ b/layout/tables/nsTableWrapperFrame.h
@@ -80,21 +80,21 @@ public:
auto bEnd = bStart + innerTable->BSize(aWM);
*aBaseline = BSize(aWM) - (bEnd - offset);
}
return true;
}
return false;
}
- virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override;
- virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override;
+ virtual nscoord GetMinISize(gfxContext *aRenderingContext) override;
+ virtual nscoord GetPrefISize(gfxContext *aRenderingContext) override;
virtual mozilla::LogicalSize
- ComputeAutoSize(nsRenderingContext* aRenderingContext,
+ ComputeAutoSize(gfxContext* aRenderingContext,
mozilla::WritingMode aWM,
const mozilla::LogicalSize& aCBSize,
nscoord aAvailableISize,
const mozilla::LogicalSize& aMargin,
const mozilla::LogicalSize& aBorder,
const mozilla::LogicalSize& aPadding,
ComputeSizeFlags aFlags) override;
@@ -277,17 +277,17 @@ protected:
}
/**
* Helper for ComputeAutoSize.
* Compute the margin-box inline size of aChildFrame given the inputs.
* If aMarginResult is non-null, fill it with the part of the
* margin-isize that was contributed by the margin.
*/
- nscoord ChildShrinkWrapISize(nsRenderingContext* aRenderingContext,
+ nscoord ChildShrinkWrapISize(gfxContext* aRenderingContext,
nsIFrame* aChildFrame,
mozilla::WritingMode aWM,
mozilla::LogicalSize aCBSize,
nscoord aAvailableISize,
nscoord* aMarginResult = nullptr) const;
private:
nsFrameList mCaptionFrames;
--- a/layout/xul/nsBoxFrame.cpp
+++ b/layout/xul/nsBoxFrame.cpp
@@ -585,17 +585,17 @@ static void printSize(char * aDesc, nsco
printf("UC");
} else {
printf("%d", aSize);
}
}
#endif
/* virtual */ nscoord
-nsBoxFrame::GetMinISize(nsRenderingContext *aRenderingContext)
+nsBoxFrame::GetMinISize(gfxContext *aRenderingContext)
{
nscoord result;
DISPLAY_MIN_WIDTH(this, result);
nsBoxLayoutState state(PresContext(), aRenderingContext);
nsSize minSize = GetXULMinSize(state);
// GetXULMinSize returns border-box width, and we want to return content
@@ -607,17 +607,17 @@ nsBoxFrame::GetMinISize(nsRenderingConte
result = minSize.width - bp.LeftRight();
result = std::max(result, 0);
return result;
}
/* virtual */ nscoord
-nsBoxFrame::GetPrefISize(nsRenderingContext *aRenderingContext)
+nsBoxFrame::GetPrefISize(gfxContext *aRenderingContext)
{
nscoord result;
DISPLAY_PREF_WIDTH(this, result);
nsBoxLayoutState state(PresContext(), aRenderingContext);
nsSize prefSize = GetXULPrefSize(state);
// GetXULPrefSize returns border-box width, and we want to return content
@@ -1287,23 +1287,23 @@ public:
virtual void HitTest(nsDisplayListBuilder* aBuilder, nsRect aRect,
HitTestState* aState, nsTArray<nsIFrame*> *aOutFrames) {
nsPoint rectCenter(aRect.x + aRect.width / 2, aRect.y + aRect.height / 2);
static_cast<nsBoxFrame*>(mFrame)->
DisplayDebugInfoFor(this, rectCenter - ToReferenceFrame());
aOutFrames->AppendElement(this);
}
virtual void Paint(nsDisplayListBuilder* aBuilder
- nsRenderingContext* aCtx);
+ gfxContext* aCtx);
NS_DISPLAY_DECL_NAME("XULDebug", TYPE_XUL_DEBUG)
};
void
nsDisplayXULDebug::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx)
+ gfxContext* aCtx)
{
static_cast<nsBoxFrame*>(mFrame)->
PaintXULDebugOverlay(*aCtx->GetDrawTarget(), ToReferenceFrame());
}
static void
PaintXULDebugBackground(nsIFrame* aFrame, DrawTarget* aDrawTarget,
const nsRect& aDirtyRect, nsPoint aPt)
--- a/layout/xul/nsBoxFrame.h
+++ b/layout/xul/nsBoxFrame.h
@@ -84,18 +84,18 @@ public:
nsIFrame* aPrevInFlow) override;
virtual nsresult AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType) override;
virtual void MarkIntrinsicISizesDirty() override;
- virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override;
- virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override;
+ virtual nscoord GetMinISize(gfxContext *aRenderingContext) override;
+ virtual nscoord GetPrefISize(gfxContext *aRenderingContext) override;
virtual void Reflow(nsPresContext* aPresContext,
ReflowOutput& aDesiredSize,
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus) override;
virtual void SetInitialChildList(ChildListID aListID,
nsFrameList& aChildList) override;
@@ -176,17 +176,17 @@ private:
: nsBoxFrame(aContext, kClassID, false, nullptr) {}
protected:
nsBoxFrame(nsStyleContext* aContext, ClassID aID, bool aIsRoot = false,
nsBoxLayout* aLayoutManager = nullptr);
virtual ~nsBoxFrame();
#ifdef DEBUG_LAYOUT
virtual void GetBoxName(nsAutoString& aName) override;
- void PaintXULDebugBackground(nsRenderingContext& aRenderingContext,
+ void PaintXULDebugBackground(gfxContext& aRenderingContext,
nsPoint aPt);
void PaintXULDebugOverlay(DrawTarget& aRenderingContext,
nsPoint aPt);
#endif
virtual bool GetInitialEqualSize(bool& aEqualSize);
virtual void GetInitialOrientation(bool& aIsHorizontal);
virtual void GetInitialDirection(bool& aIsNormal);
--- a/layout/xul/nsBoxLayoutState.cpp
+++ b/layout/xul/nsBoxLayoutState.cpp
@@ -8,17 +8,17 @@
// Netscape Communications
//
// See documentation in associated header file
//
#include "nsBoxLayoutState.h"
nsBoxLayoutState::nsBoxLayoutState(nsPresContext* aPresContext,
- nsRenderingContext* aRenderingContext,
+ gfxContext* aRenderingContext,
const ReflowInput* aOuterReflowInput,
uint16_t aReflowDepth)
: mPresContext(aPresContext)
, mRenderingContext(aRenderingContext)
, mOuterReflowInput(aOuterReflowInput)
, mLayoutFlags(0)
, mReflowDepth(aReflowDepth)
, mPaintingDisabled(false)
--- a/layout/xul/nsBoxLayoutState.h
+++ b/layout/xul/nsBoxLayoutState.h
@@ -12,29 +12,29 @@
#ifndef nsBoxLayoutState_h___
#define nsBoxLayoutState_h___
#include "nsCOMPtr.h"
#include "nsPresContext.h"
#include "nsIPresShell.h"
-class nsRenderingContext;
+class gfxContext;
namespace mozilla {
struct ReflowInput;
} // namespace mozilla
class MOZ_STACK_CLASS nsBoxLayoutState
{
using ReflowInput = mozilla::ReflowInput;
public:
explicit nsBoxLayoutState(nsPresContext* aPresContext,
- nsRenderingContext* aRenderingContext = nullptr,
+ gfxContext* aRenderingContext = nullptr,
// see OuterReflowInput() below
const ReflowInput* aOuterReflowInput = nullptr,
uint16_t aReflowDepth = 0);
nsBoxLayoutState(const nsBoxLayoutState& aState);
nsPresContext* PresContext() const { return mPresContext; }
nsIPresShell* PresShell() const { return mPresContext->PresShell(); }
@@ -44,34 +44,34 @@ public:
// if true no one under us will paint during reflow.
void SetPaintingDisabled(bool aDisable) { mPaintingDisabled = aDisable; }
bool PaintingDisabled() const { return mPaintingDisabled; }
// The rendering context may be null for specialized uses of
// nsBoxLayoutState and should be null-checked before it is used.
// However, passing a null rendering context to the constructor when
// doing box layout or intrinsic size calculation will cause bugs.
- nsRenderingContext* GetRenderingContext() const { return mRenderingContext; }
+ gfxContext* GetRenderingContext() const { return mRenderingContext; }
struct AutoReflowDepth {
explicit AutoReflowDepth(nsBoxLayoutState& aState)
: mState(aState) { ++mState.mReflowDepth; }
~AutoReflowDepth() { --mState.mReflowDepth; }
nsBoxLayoutState& mState;
};
// The HTML reflow state that lives outside the box-block boundary.
// May not be set reliably yet.
const ReflowInput* OuterReflowInput() { return mOuterReflowInput; }
uint16_t GetReflowDepth() { return mReflowDepth; }
private:
RefPtr<nsPresContext> mPresContext;
- nsRenderingContext *mRenderingContext;
+ gfxContext *mRenderingContext;
const ReflowInput *mOuterReflowInput;
uint32_t mLayoutFlags;
uint16_t mReflowDepth;
bool mPaintingDisabled;
};
#endif
--- a/layout/xul/nsGroupBoxFrame.cpp
+++ b/layout/xul/nsGroupBoxFrame.cpp
@@ -2,20 +2,20 @@
/* 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/. */
// YY need to pass isMultiple before create called
#include "nsBoxFrame.h"
+#include "gfxContext.h"
#include "mozilla/gfx/2D.h"
#include "nsCSSRendering.h"
#include "nsLayoutUtils.h"
-#include "nsRenderingContext.h"
#include "nsStyleContext.h"
#include "nsDisplayList.h"
using namespace mozilla;
using namespace mozilla::gfx;
using namespace mozilla::image;
class nsGroupBoxFrame final : public nsBoxFrame
@@ -35,17 +35,17 @@ public:
#ifdef DEBUG_FRAME_DUMP
virtual nsresult GetFrameName(nsAString& aResult) const override {
return MakeFrameName(NS_LITERAL_STRING("GroupBoxFrame"), aResult);
}
#endif
virtual bool HonorPrintBackgroundSettings() override { return false; }
- DrawResult PaintBorder(nsRenderingContext& aRenderingContext,
+ DrawResult PaintBorder(gfxContext& aRenderingContext,
nsPoint aPt,
const nsRect& aDirtyRect);
nsRect GetBackgroundRectRelativeToSelf(nscoord* aOutYOffset = nullptr, nsRect* aOutGroupRect = nullptr);
// make sure we our kids get our orient and align instead of us.
// our child box has no content node so it will search for a parent with one.
// that will be us.
virtual void GetInitialOrientation(bool& aHorizontal) override { aHorizontal = false; }
@@ -102,17 +102,17 @@ public:
void ComputeInvalidationRegion(nsDisplayListBuilder* aBuilder,
const nsDisplayItemGeometry* aGeometry,
nsRegion *aInvalidRegion) override;
virtual void HitTest(nsDisplayListBuilder* aBuilder, const nsRect& aRect,
HitTestState* aState, nsTArray<nsIFrame*> *aOutFrames) override {
aOutFrames->AppendElement(mFrame);
}
virtual void Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) override;
+ gfxContext* aCtx) override;
NS_DISPLAY_DECL_NAME("XULGroupBackground", TYPE_XUL_GROUP_BACKGROUND)
};
nsDisplayItemGeometry*
nsDisplayXULGroupBorder::AllocateGeometry(nsDisplayListBuilder* aBuilder)
{
return new nsDisplayItemGenericImageGeometry(this, aBuilder);
}
@@ -132,17 +132,17 @@ nsDisplayXULGroupBorder::ComputeInvalida
aInvalidRegion->Or(*aInvalidRegion, GetBounds(aBuilder, &snap));
}
nsDisplayItem::ComputeInvalidationRegion(aBuilder, aGeometry, aInvalidRegion);
}
void
nsDisplayXULGroupBorder::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx)
+ gfxContext* aCtx)
{
DrawResult result = static_cast<nsGroupBoxFrame*>(mFrame)
->PaintBorder(*aCtx, ToReferenceFrame(), mVisibleRect);
nsDisplayItemGenericImageGeometry::UpdateDrawResult(this, result);
}
void
@@ -191,21 +191,20 @@ nsGroupBoxFrame::GetBackgroundRectRelati
if (aOutGroupRect) {
*aOutGroupRect = groupRect;
}
return nsRect(0, yoff, mRect.width, mRect.height - yoff);
}
DrawResult
-nsGroupBoxFrame::PaintBorder(nsRenderingContext& aRenderingContext,
+nsGroupBoxFrame::PaintBorder(gfxContext& aRenderingContext,
nsPoint aPt, const nsRect& aDirtyRect) {
DrawTarget* drawTarget = aRenderingContext.GetDrawTarget();
- gfxContext* gfx = aRenderingContext.ThebesContext();
Sides skipSides;
const nsStyleBorder* borderStyleData = StyleBorder();
const nsMargin& border = borderStyleData->GetComputedBorder();
nsPresContext* presContext = PresContext();
nsRect groupRect;
nsIFrame* groupBox = GetCaptionBox(groupRect);
@@ -221,52 +220,55 @@ nsGroupBoxFrame::PaintBorder(nsRendering
// we should probably use PaintBorderEdges to do this but for now just use clipping
// to achieve the same effect.
// draw left side
nsRect clipRect(rect);
clipRect.width = groupRect.x - rect.x;
clipRect.height = border.top;
- gfx->Save();
- gfx->Clip(NSRectToSnappedRect(clipRect, appUnitsPerDevPixel, *drawTarget));
+ aRenderingContext.Save();
+ aRenderingContext.Clip(
+ NSRectToSnappedRect(clipRect, appUnitsPerDevPixel, *drawTarget));
result &=
nsCSSRendering::PaintBorder(presContext, aRenderingContext, this,
aDirtyRect, rect, mStyleContext,
PaintBorderFlags::SYNC_DECODE_IMAGES, skipSides);
- gfx->Restore();
+ aRenderingContext.Restore();
// draw right side
clipRect = rect;
clipRect.x = groupRect.XMost();
clipRect.width = rect.XMost() - groupRect.XMost();
clipRect.height = border.top;
- gfx->Save();
- gfx->Clip(NSRectToSnappedRect(clipRect, appUnitsPerDevPixel, *drawTarget));
+ aRenderingContext.Save();
+ aRenderingContext.Clip(
+ NSRectToSnappedRect(clipRect, appUnitsPerDevPixel, *drawTarget));
result &=
nsCSSRendering::PaintBorder(presContext, aRenderingContext, this,
aDirtyRect, rect, mStyleContext,
PaintBorderFlags::SYNC_DECODE_IMAGES, skipSides);
- gfx->Restore();
+ aRenderingContext.Restore();
// draw bottom
clipRect = rect;
clipRect.y += border.top;
clipRect.height = mRect.height - (yoff + border.top);
-
- gfx->Save();
- gfx->Clip(NSRectToSnappedRect(clipRect, appUnitsPerDevPixel, *drawTarget));
+
+ aRenderingContext.Save();
+ aRenderingContext.Clip(
+ NSRectToSnappedRect(clipRect, appUnitsPerDevPixel, *drawTarget));
result &=
nsCSSRendering::PaintBorder(presContext, aRenderingContext, this,
aDirtyRect, rect, mStyleContext,
PaintBorderFlags::SYNC_DECODE_IMAGES, skipSides);
- gfx->Restore();
+ aRenderingContext.Restore();
} else {
result &=
nsCSSRendering::PaintBorder(presContext, aRenderingContext, this,
aDirtyRect, nsRect(aPt, GetSize()),
mStyleContext,
PaintBorderFlags::SYNC_DECODE_IMAGES, skipSides);
}
--- a/layout/xul/nsImageBoxFrame.cpp
+++ b/layout/xul/nsImageBoxFrame.cpp
@@ -5,19 +5,19 @@
//
// Eric Vaughan
// Netscape Communications
//
// See documentation in associated header file
//
+#include "gfxContext.h"
#include "nsImageBoxFrame.h"
#include "nsGkAtoms.h"
-#include "nsRenderingContext.h"
#include "nsStyleContext.h"
#include "nsStyleConsts.h"
#include "nsStyleUtil.h"
#include "nsCOMPtr.h"
#include "nsPresContext.h"
#include "nsBoxLayoutState.h"
#include "nsHTMLParts.h"
@@ -334,17 +334,17 @@ nsImageBoxFrame::BuildDisplayList(nsDisp
new (aBuilder) nsDisplayXULImage(aBuilder, this));
CreateOwnLayerIfNeeded(aBuilder, &list);
aLists.Content()->AppendToTop(&list);
}
DrawResult
-nsImageBoxFrame::PaintImage(nsRenderingContext& aRenderingContext,
+nsImageBoxFrame::PaintImage(gfxContext& aRenderingContext,
const nsRect& aDirtyRect, nsPoint aPt,
uint32_t aFlags)
{
if (!mImageRequest) {
// This probably means we're drawn by a native theme.
return DrawResult::SUCCESS;
}
@@ -372,17 +372,17 @@ nsImageBoxFrame::PaintImage(nsRenderingC
return DrawResult::TEMPORARY_ERROR;
}
bool hasSubRect = !mUseSrcAttr && (mSubRect.width > 0 || mSubRect.height > 0);
Maybe<SVGImageContext> svgContext;
SVGImageContext::MaybeStoreContextPaint(svgContext, this, imgCon);
return nsLayoutUtils::DrawSingleImage(
- *aRenderingContext.ThebesContext(),
+ aRenderingContext,
PresContext(), imgCon,
nsLayoutUtils::GetSamplingFilterForFrame(this),
dest, dirty,
svgContext, aFlags,
anchorPoint.ptrOr(nullptr),
hasSubRect ? &mSubRect : nullptr);
}
@@ -427,17 +427,17 @@ nsImageBoxFrame::GetDestRect(const nsPoi
StylePosition(),
aAnchorPoint.ptr());
}
return dest;
}
void nsDisplayXULImage::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx)
+ gfxContext* aCtx)
{
// Even though we call StartDecoding when we get a new image we pass
// FLAG_SYNC_DECODE_IF_FAST here for the case where the size we draw at is not
// the intrinsic size of the image and we aren't likely to implement predictive
// decoding at the correct size for this class like nsImageFrame has.
uint32_t flags = imgIContainer::FLAG_SYNC_DECODE_IF_FAST;
if (aBuilder->ShouldSyncDecodeImages())
flags |= imgIContainer::FLAG_SYNC_DECODE;
--- a/layout/xul/nsImageBoxFrame.h
+++ b/layout/xul/nsImageBoxFrame.h
@@ -86,17 +86,17 @@ public:
void UpdateLoadFlags();
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) override;
virtual ~nsImageBoxFrame();
- DrawResult PaintImage(nsRenderingContext& aRenderingContext,
+ DrawResult PaintImage(gfxContext& aRenderingContext,
const nsRect& aDirtyRect,
nsPoint aPt, uint32_t aFlags);
bool CanOptimizeToImageLayer();
nsRect GetDestRect(const nsPoint& aOffset, Maybe<nsPoint>& aAnchorPoint);
protected:
@@ -153,13 +153,13 @@ public:
}
virtual nsDisplayItemGeometry* AllocateGeometry(nsDisplayListBuilder* aBuilder) override;
virtual void ComputeInvalidationRegion(nsDisplayListBuilder* aBuilder,
const nsDisplayItemGeometry* aGeometry,
nsRegion* aInvalidRegion) override;
// Doesn't handle HitTest because nsLeafBoxFrame already creates an
// event receiver for us
virtual void Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) override;
+ gfxContext* aCtx) override;
NS_DISPLAY_DECL_NAME("XULImage", TYPE_XUL_IMAGE)
};
#endif /* nsImageBoxFrame_h___ */
--- a/layout/xul/nsLeafBoxFrame.cpp
+++ b/layout/xul/nsLeafBoxFrame.cpp
@@ -114,17 +114,17 @@ nsLeafBoxFrame::BuildDisplayList(nsDispl
if (!aBuilder->IsForEventDelivery() || !IsVisibleForPainting(aBuilder))
return;
aLists.Content()->AppendNewToTop(new (aBuilder)
nsDisplayEventReceiver(aBuilder, this));
}
/* virtual */ nscoord
-nsLeafBoxFrame::GetMinISize(nsRenderingContext *aRenderingContext)
+nsLeafBoxFrame::GetMinISize(gfxContext *aRenderingContext)
{
nscoord result;
DISPLAY_MIN_WIDTH(this, result);
nsBoxLayoutState state(PresContext(), aRenderingContext);
WritingMode wm = GetWritingMode();
LogicalSize minSize(wm, GetXULMinSize(state));
@@ -136,17 +136,17 @@ nsLeafBoxFrame::GetMinISize(nsRenderingC
GetXULBorderAndPadding(bp);
result = minSize.ISize(wm) - LogicalMargin(wm, bp).IStartEnd(wm);
return result;
}
/* virtual */ nscoord
-nsLeafBoxFrame::GetPrefISize(nsRenderingContext *aRenderingContext)
+nsLeafBoxFrame::GetPrefISize(gfxContext *aRenderingContext)
{
nscoord result;
DISPLAY_PREF_WIDTH(this, result);
nsBoxLayoutState state(PresContext(), aRenderingContext);
WritingMode wm = GetWritingMode();
LogicalSize prefSize(wm, GetXULPrefSize(state));
@@ -165,17 +165,17 @@ nsLeafBoxFrame::GetPrefISize(nsRendering
nscoord
nsLeafBoxFrame::GetIntrinsicISize()
{
// No intrinsic width
return 0;
}
LogicalSize
-nsLeafBoxFrame::ComputeAutoSize(nsRenderingContext* aRenderingContext,
+nsLeafBoxFrame::ComputeAutoSize(gfxContext* aRenderingContext,
WritingMode aWM,
const LogicalSize& aCBSize,
nscoord aAvailableISize,
const LogicalSize& aMargin,
const LogicalSize& aBorder,
const LogicalSize& aPadding,
ComputeSizeFlags aFlags)
{
--- a/layout/xul/nsLeafBoxFrame.h
+++ b/layout/xul/nsLeafBoxFrame.h
@@ -32,22 +32,22 @@ public:
#ifdef DEBUG_FRAME_DUMP
virtual nsresult GetFrameName(nsAString& aResult) const override;
#endif
// nsIHTMLReflow overrides
virtual void MarkIntrinsicISizesDirty() override;
- virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override;
- virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override;
+ virtual nscoord GetMinISize(gfxContext *aRenderingContext) override;
+ virtual nscoord GetPrefISize(gfxContext *aRenderingContext) override;
// Our auto size is that provided by nsFrame, not nsLeafFrame
virtual mozilla::LogicalSize
- ComputeAutoSize(nsRenderingContext* aRenderingContext,
+ ComputeAutoSize(gfxContext* aRenderingContext,
mozilla::WritingMode aWM,
const mozilla::LogicalSize& aCBSize,
nscoord aAvailableISize,
const mozilla::LogicalSize& aMargin,
const mozilla::LogicalSize& aBorder,
const mozilla::LogicalSize& aPadding,
ComputeSizeFlags aFlags) override;
--- a/layout/xul/nsListBoxBodyFrame.cpp
+++ b/layout/xul/nsListBoxBodyFrame.cpp
@@ -28,17 +28,17 @@
#include "nsITimer.h"
#include "mozilla/StyleSetHandle.h"
#include "mozilla/StyleSetHandleInlines.h"
#include "nsPIBoxObject.h"
#include "nsLayoutUtils.h"
#include "nsPIListBoxObject.h"
#include "nsContentUtils.h"
#include "ChildIterator.h"
-#include "nsRenderingContext.h"
+#include "gfxContext.h"
#include "prtime.h"
#include <algorithm>
#ifdef ACCESSIBILITY
#include "nsAccessibilityService.h"
#endif
using namespace mozilla;
@@ -728,17 +728,17 @@ nsListBoxBodyFrame::ComputeIntrinsicISiz
width += margin.LeftRight();
width += styleContext->StyleBorder()->GetComputedBorder().LeftRight();
if (styleContext->StyleMargin()->GetMargin(margin))
width += margin.LeftRight();
FlattenedChildIterator iter(mContent);
for (nsIContent* child = iter.GetNextChild(); child; child = iter.GetNextChild()) {
if (child->IsXULElement(nsGkAtoms::listitem)) {
- nsRenderingContext* rendContext = aBoxLayoutState.GetRenderingContext();
+ gfxContext* rendContext = aBoxLayoutState.GetRenderingContext();
if (rendContext) {
nsAutoString value;
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);
}
--- a/layout/xul/nsSplitterFrame.cpp
+++ b/layout/xul/nsSplitterFrame.cpp
@@ -5,22 +5,22 @@
//
// Eric Vaughan
// Netscape Communications
//
// See documentation in associated header file
//
+#include "gfxContext.h"
#include "nsSplitterFrame.h"
#include "nsGkAtoms.h"
#include "nsIDOMElement.h"
#include "nsXULElement.h"
#include "nsPresContext.h"
-#include "nsRenderingContext.h"
#include "nsIDocument.h"
#include "nsNameSpaceManager.h"
#include "nsScrollbarButtonFrame.h"
#include "nsIDOMEventListener.h"
#include "nsIDOMMouseEvent.h"
#include "nsIPresShell.h"
#include "nsFrameList.h"
#include "nsHTMLParts.h"
@@ -631,19 +631,19 @@ nsSplitterFrameInner::MouseDown(nsIDOMEv
if (childIndex <= 0)
return NS_OK;
int32_t childCount = siblingList.GetLength();
// if it's the last index then we need to allow for resizeafter="grow"
if (childIndex == childCount - 1 && GetResizeAfter() != Grow)
return NS_OK;
- nsRenderingContext rc(
- outerPresContext->PresShell()->CreateReferenceRenderingContext());
- nsBoxLayoutState state(outerPresContext, &rc);
+ RefPtr<gfxContext> rc =
+ outerPresContext->PresShell()->CreateReferenceRenderingContext();
+ nsBoxLayoutState state(outerPresContext, rc);
mCurrentPos = 0;
mPressed = true;
mDidDrag = false;
EnsureOrient();
bool isHorizontal = !mOuter->IsXULHorizontal();
--- a/layout/xul/nsTextBoxFrame.cpp
+++ b/layout/xul/nsTextBoxFrame.cpp
@@ -9,17 +9,17 @@
#include "gfx2DGlue.h"
#include "gfxUtils.h"
#include "mozilla/gfx/2D.h"
#include "nsFontMetrics.h"
#include "nsReadableUtils.h"
#include "nsCOMPtr.h"
#include "nsGkAtoms.h"
#include "nsPresContext.h"
-#include "nsRenderingContext.h"
+#include "gfxContext.h"
#include "nsStyleContext.h"
#include "nsIContent.h"
#include "nsNameSpaceManager.h"
#include "nsBoxLayoutState.h"
#include "nsMenuBarListener.h"
#include "nsXPIDLString.h"
#include "nsIServiceManager.h"
#include "nsIDOMElement.h"
@@ -292,47 +292,47 @@ public:
}
#ifdef NS_BUILD_REFCNT_LOGGING
virtual ~nsDisplayXULTextBox() {
MOZ_COUNT_DTOR(nsDisplayXULTextBox);
}
#endif
virtual void Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) override;
+ gfxContext* aCtx) override;
virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder,
bool* aSnap) override;
NS_DISPLAY_DECL_NAME("XULTextBox", TYPE_XUL_TEXT_BOX)
virtual nsRect GetComponentAlphaBounds(nsDisplayListBuilder* aBuilder) override;
virtual void DisableComponentAlpha() override {
mDisableSubpixelAA = true;
}
- void PaintTextToContext(nsRenderingContext* aCtx,
+ void PaintTextToContext(gfxContext* aCtx,
nsPoint aOffset,
const nscolor* aColor);
bool mDisableSubpixelAA;
};
static void
-PaintTextShadowCallback(nsRenderingContext* aCtx,
+PaintTextShadowCallback(gfxContext* aCtx,
nsPoint aShadowOffset,
const nscolor& aShadowColor,
void* aData)
{
reinterpret_cast<nsDisplayXULTextBox*>(aData)->
PaintTextToContext(aCtx, aShadowOffset, &aShadowColor);
}
void
nsDisplayXULTextBox::Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx)
+ gfxContext* aCtx)
{
DrawTargetAutoDisableSubpixelAntialiasing disable(aCtx->GetDrawTarget(),
mDisableSubpixelAA);
// Paint the text shadow before doing any foreground stuff
nsRect drawRect = static_cast<nsTextBoxFrame*>(mFrame)->mTextDrawRect +
ToReferenceFrame();
nsLayoutUtils::PaintTextShadow(mFrame, aCtx,
@@ -340,17 +340,17 @@ nsDisplayXULTextBox::Paint(nsDisplayList
mFrame->StyleColor()->mColor,
PaintTextShadowCallback,
(void*)this);
PaintTextToContext(aCtx, nsPoint(0, 0), nullptr);
}
void
-nsDisplayXULTextBox::PaintTextToContext(nsRenderingContext* aCtx,
+nsDisplayXULTextBox::PaintTextToContext(gfxContext* aCtx,
nsPoint aOffset,
const nscolor* aColor)
{
static_cast<nsTextBoxFrame*>(mFrame)->
PaintTitle(*aCtx, mVisibleRect, ToReferenceFrame() + aOffset, aColor);
}
nsRect
@@ -376,29 +376,29 @@ nsTextBoxFrame::BuildDisplayList(nsDispl
nsLeafBoxFrame::BuildDisplayList(aBuilder, aDirtyRect, aLists);
aLists.Content()->AppendNewToTop(new (aBuilder)
nsDisplayXULTextBox(aBuilder, this));
}
void
-nsTextBoxFrame::PaintTitle(nsRenderingContext& aRenderingContext,
+nsTextBoxFrame::PaintTitle(gfxContext& aRenderingContext,
const nsRect& aDirtyRect,
nsPoint aPt,
const nscolor* aOverrideColor)
{
if (mTitle.IsEmpty())
return;
DrawText(aRenderingContext, aDirtyRect, mTextDrawRect + aPt, aOverrideColor);
}
void
-nsTextBoxFrame::DrawText(nsRenderingContext& aRenderingContext,
+nsTextBoxFrame::DrawText(gfxContext& aRenderingContext,
const nsRect& aDirtyRect,
const nsRect& aTextRect,
const nscolor* aOverrideColor)
{
nsPresContext* presContext = PresContext();
int32_t appUnitsPerDevPixel = presContext->AppUnitsPerDevPixel();
DrawTarget* drawTarget = aRenderingContext.GetDrawTarget();
@@ -517,25 +517,25 @@ nsTextBoxFrame::DrawText(nsRenderingCont
params.color = overColor;
params.offset = params.ascent;
params.decoration = NS_STYLE_TEXT_DECORATION_LINE_OVERLINE;
params.style = overStyle;
nsCSSRendering::PaintDecorationLine(this, *drawTarget, params);
}
}
- nsRenderingContext refContext(
- PresContext()->PresShell()->CreateReferenceRenderingContext());
- DrawTarget* refDrawTarget = refContext.GetDrawTarget();
+ RefPtr<gfxContext> refContext =
+ PresContext()->PresShell()->CreateReferenceRenderingContext();
+ DrawTarget* refDrawTarget = refContext->GetDrawTarget();
CalculateUnderline(refDrawTarget, *fontMet);
nscolor c = aOverrideColor ? *aOverrideColor : StyleColor()->mColor;
ColorPattern color(ToDeviceColor(c));
- aRenderingContext.ThebesContext()->SetColor(Color::FromABGR(c));
+ aRenderingContext.SetColor(Color::FromABGR(c));
nsresult rv = NS_ERROR_FAILURE;
if (mState & NS_FRAME_IS_BIDI) {
presContext->SetBidiEnabled();
nsBidiLevel level = nsBidiPresUtils::BidiLevelFromStyle(StyleContext());
if (mAccessKeyInfo && mAccessKeyInfo->mAccesskeyIndex != kNotFound) {
// We let the RenderText function calculate the mnemonic's
@@ -620,17 +620,17 @@ nsTextBoxFrame::CalculateUnderline(DrawT
nscoord offset, baseline;
aFontMetrics.GetUnderline(offset, mAccessKeyInfo->mAccessUnderlineSize);
baseline = aFontMetrics.MaxAscent();
mAccessKeyInfo->mAccessOffset = baseline - offset;
}
}
nscoord
-nsTextBoxFrame::CalculateTitleForWidth(nsRenderingContext& aRenderingContext,
+nsTextBoxFrame::CalculateTitleForWidth(gfxContext& aRenderingContext,
nscoord aWidth)
{
DrawTarget* drawTarget = aRenderingContext.GetDrawTarget();
if (mTitle.IsEmpty()) {
mCroppedTitle.Truncate();
return 0;
}
@@ -1049,17 +1049,17 @@ nsTextBoxFrame::ComputesOwnOverflowArea(
/* virtual */ void
nsTextBoxFrame::MarkIntrinsicISizesDirty()
{
mNeedsRecalc = true;
nsLeafBoxFrame::MarkIntrinsicISizesDirty();
}
void
-nsTextBoxFrame::GetTextSize(nsRenderingContext& aRenderingContext,
+nsTextBoxFrame::GetTextSize(gfxContext& aRenderingContext,
const nsString& aString,
nsSize& aSize, nscoord& aAscent)
{
RefPtr<nsFontMetrics> fontMet =
nsLayoutUtils::GetFontMetricsForFrame(this, 1.0f);
aSize.height = fontMet->MaxHeight();
aSize.width =
nsLayoutUtils::AppUnitWidthOfStringBidi(aString, this, *fontMet,
@@ -1067,30 +1067,30 @@ nsTextBoxFrame::GetTextSize(nsRenderingC
aAscent = fontMet->MaxAscent();
}
void
nsTextBoxFrame::CalcTextSize(nsBoxLayoutState& aBoxLayoutState)
{
if (mNeedsRecalc) {
nsSize size;
- nsRenderingContext* rendContext = aBoxLayoutState.GetRenderingContext();
+ gfxContext* rendContext = aBoxLayoutState.GetRenderingContext();
if (rendContext) {
GetTextSize(*rendContext, mTitle, size, mAscent);
if (GetWritingMode().IsVertical()) {
Swap(size.width, size.height);
}
mTextSize = size;
mNeedsRecalc = false;
}
}
}
void
-nsTextBoxFrame::CalcDrawRect(nsRenderingContext &aRenderingContext)
+nsTextBoxFrame::CalcDrawRect(gfxContext &aRenderingContext)
{
WritingMode wm = GetWritingMode();
LogicalRect textRect(wm, LogicalPoint(wm, 0, 0), GetLogicalSize(wm));
nsMargin borderPadding;
GetXULBorderAndPadding(borderPadding);
textRect.Deflate(wm, LogicalMargin(wm, borderPadding));
--- a/layout/xul/nsTextBoxFrame.h
+++ b/layout/xul/nsTextBoxFrame.h
@@ -47,17 +47,17 @@ public:
bool& aRedraw);
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) override;
virtual ~nsTextBoxFrame();
- void PaintTitle(nsRenderingContext& aRenderingContext,
+ void PaintTitle(gfxContext& aRenderingContext,
const nsRect& aDirtyRect,
nsPoint aPt,
const nscolor* aOverrideColor);
nsRect GetComponentAlphaBounds();
virtual bool ComputesOwnOverflowArea() override;
@@ -75,43 +75,43 @@ protected:
void UpdateAccessIndex();
// Recompute our title, ignoring the access key but taking into
// account text-transform.
void RecomputeTitle();
// REVIEW: SORRY! Couldn't resist devirtualizing these
void LayoutTitle(nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
const nsRect& aRect);
void CalculateUnderline(DrawTarget* aDrawTarget, nsFontMetrics& aFontMetrics);
void CalcTextSize(nsBoxLayoutState& aBoxLayoutState);
- void CalcDrawRect(nsRenderingContext &aRenderingContext);
+ void CalcDrawRect(gfxContext &aRenderingContext);
explicit nsTextBoxFrame(nsStyleContext* aContext);
- nscoord CalculateTitleForWidth(nsRenderingContext& aRenderingContext,
+ nscoord CalculateTitleForWidth(gfxContext& aRenderingContext,
nscoord aWidth);
- void GetTextSize(nsRenderingContext& aRenderingContext,
+ void GetTextSize(gfxContext& aRenderingContext,
const nsString& aString,
nsSize& aSize,
nscoord& aAscent);
nsresult RegUnregAccessKey(bool aDoReg);
private:
bool AlwaysAppendAccessKey();
bool InsertSeparatorBeforeAccessKey();
- void DrawText(nsRenderingContext& aRenderingContext,
+ void DrawText(gfxContext& aRenderingContext,
const nsRect& aDirtyRect,
const nsRect& aTextRect,
const nscolor* aOverrideColor);
nsString mTitle;
nsString mCroppedTitle;
nsString mAccessKey;
nsSize mTextSize;
--- a/layout/xul/tree/nsTreeBodyFrame.cpp
+++ b/layout/xul/tree/nsTreeBodyFrame.cpp
@@ -24,16 +24,17 @@
#include "nsTreeBodyFrame.h"
#include "nsTreeSelection.h"
#include "nsTreeImageListener.h"
#include "nsGkAtoms.h"
#include "nsCSSAnonBoxes.h"
+#include "gfxContext.h"
#include "nsIContent.h"
#include "nsStyleContext.h"
#include "nsIBoxObject.h"
#include "nsIDOMCustomEvent.h"
#include "nsIDOMMouseEvent.h"
#include "nsIDOMElement.h"
#include "nsIDOMNodeList.h"
#include "nsIDOMDocument.h"
@@ -59,17 +60,16 @@
#include "imgIContainer.h"
#include "imgILoader.h"
#include "mozilla/dom/NodeInfo.h"
#include "nsContentUtils.h"
#include "nsLayoutUtils.h"
#include "nsIScrollableFrame.h"
#include "nsDisplayList.h"
#include "mozilla/dom/TreeBoxObject.h"
-#include "nsRenderingContext.h"
#include "nsIScriptableRegion.h"
#include <algorithm>
#include "ScrollbarActivity.h"
#ifdef ACCESSIBILITY
#include "nsAccessibilityService.h"
#include "nsIWritablePropertyBag2.h"
#endif
@@ -241,25 +241,25 @@ nsTreeBodyFrame::CalcMaxRowWidth()
nsStyleContext* rowContext = GetPseudoStyleContext(nsCSSAnonBoxes::moztreerow);
nsMargin rowMargin(0,0,0,0);
GetBorderPadding(rowContext, rowMargin);
nscoord rowWidth;
nsTreeColumn* col;
- nsRenderingContext rc(
- PresContext()->PresShell()->CreateReferenceRenderingContext());
+ RefPtr<gfxContext> rc =
+ PresContext()->PresShell()->CreateReferenceRenderingContext();
for (int32_t row = 0; row < mRowCount; ++row) {
rowWidth = 0;
for (col = mColumns->GetFirstColumn(); col; col = col->GetNext()) {
nscoord desiredWidth, currentWidth;
- nsresult rv = GetCellWidth(row, col, &rc, desiredWidth, currentWidth);
+ nsresult rv = GetCellWidth(row, col, rc, desiredWidth, currentWidth);
if (NS_FAILED(rv)) {
NS_NOTREACHED("invalid column");
continue;
}
rowWidth += desiredWidth;
}
if (rowWidth > mStringWidth)
@@ -1162,18 +1162,18 @@ nsTreeBodyFrame::GetCoordsForCellItem(in
}
// Since we're not looking for the cell, and since the cell isn't a cycler,
// we're looking for some subcomponent, and now we need to subtract the
// borders and padding of the cell from cellRect so this does not
// interfere with our computations.
AdjustForBorderPadding(cellContext, cellRect);
- nsRenderingContext rc(
- presContext->PresShell()->CreateReferenceRenderingContext());
+ RefPtr<gfxContext> rc =
+ presContext->PresShell()->CreateReferenceRenderingContext();
// Now we'll start making our way across the cell, starting at the edge of
// the cell and proceeding until we hit the right edge. |cellX| is the
// working X value that we will increment as we crawl from left to right.
nscoord cellX = cellRect.x;
nscoord remainWidth = cellRect.width;
if (currCol->IsPrimary()) {
@@ -1264,17 +1264,17 @@ nsTreeBodyFrame::GetCoordsForCellItem(in
textRect.y += (textRect.height - height) / 2;
textRect.height = height;
}
nsMargin bp(0,0,0,0);
GetBorderPadding(textContext, bp);
textRect.height += bp.top + bp.bottom;
- AdjustForCellText(cellText, aRow, currCol, rc, *fm, textRect);
+ AdjustForCellText(cellText, aRow, currCol, *rc, *fm, textRect);
theRect = textRect;
}
if (isRTL)
theRect.x = mInnerBox.width - theRect.x - theRect.width;
*aX = nsPresContext::AppUnitsToIntCSSPixels(theRect.x);
@@ -1308,17 +1308,17 @@ nsTreeBodyFrame::CheckTextForBidi(nsAuto
if (HasRTLChars(aText)) {
PresContext()->SetBidiEnabled();
}
}
void
nsTreeBodyFrame::AdjustForCellText(nsAutoString& aText,
int32_t aRowIndex, nsTreeColumn* aColumn,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
nsFontMetrics& aFontMetrics,
nsRect& aTextRect)
{
NS_PRECONDITION(aColumn && aColumn->GetFrame(), "invalid column passed");
DrawTarget* drawTarget = aRenderingContext.GetDrawTarget();
nscoord maxWidth = aTextRect.width;
@@ -1517,18 +1517,18 @@ nsTreeBodyFrame::GetItemWithinCellAt(nsc
nscoord currX = cellRect.x;
nscoord remainingWidth = cellRect.width;
// Handle right alignment hit testing.
bool isRTL = StyleVisibility()->mDirection == NS_STYLE_DIRECTION_RTL;
nsPresContext* presContext = PresContext();
- nsRenderingContext rc(
- presContext->PresShell()->CreateReferenceRenderingContext());
+ RefPtr<gfxContext> rc =
+ presContext->PresShell()->CreateReferenceRenderingContext();
if (aColumn->IsPrimary()) {
// If we're the primary column, we have indentation and a twisty.
int32_t level;
mView->GetLevel(aRowIndex, &level);
if (!isRTL)
currX += mIndentation*level;
@@ -1619,17 +1619,17 @@ nsTreeBodyFrame::GetItemWithinCellAt(nsc
nsMargin textMargin;
textContext->StyleMargin()->GetMargin(textMargin);
textRect.Deflate(textMargin);
AdjustForBorderPadding(textContext, textRect);
RefPtr<nsFontMetrics> fm =
nsLayoutUtils::GetFontMetricsForStyleContext(textContext);
- AdjustForCellText(cellText, aRowIndex, aColumn, rc, *fm, textRect);
+ AdjustForCellText(cellText, aRowIndex, aColumn, *rc, *fm, textRect);
if (aX >= textRect.x && aX < textRect.x + textRect.width)
return nsCSSAnonBoxes::moztreecelltext;
else
return nsCSSAnonBoxes::moztreecell;
}
void
@@ -1672,17 +1672,17 @@ nsTreeBodyFrame::GetCellAt(nscoord aX, n
*aChildElt = GetItemWithinCellAt(aX, cellRect, *aRow, currCol);
break;
}
}
}
nsresult
nsTreeBodyFrame::GetCellWidth(int32_t aRow, nsTreeColumn* aCol,
- nsRenderingContext* aRenderingContext,
+ gfxContext* aRenderingContext,
nscoord& aDesiredSize, nscoord& aCurrentSize)
{
NS_PRECONDITION(aCol, "aCol must not be null");
NS_PRECONDITION(aRenderingContext, "aRenderingContext must not be null");
// The rect for the current cell.
nscoord colWidth;
nsresult rv = aCol->GetWidthInTwips(this, &colWidth);
@@ -1765,20 +1765,20 @@ nsTreeBodyFrame::IsCellCropped(int32_t a
{
nscoord currentSize, desiredSize;
nsresult rv;
RefPtr<nsTreeColumn> col = GetColumnImpl(aCol);
if (!col)
return NS_ERROR_INVALID_ARG;
- nsRenderingContext rc(
- PresContext()->PresShell()->CreateReferenceRenderingContext());
-
- rv = GetCellWidth(aRow, col, &rc, desiredSize, currentSize);
+ RefPtr<gfxContext> rc =
+ PresContext()->PresShell()->CreateReferenceRenderingContext();
+
+ rv = GetCellWidth(aRow, col, rc, desiredSize, currentSize);
NS_ENSURE_SUCCESS(rv, rv);
*_retval = desiredSize > currentSize;
return NS_OK;
}
void
@@ -2802,17 +2802,17 @@ public:
bool snap;
aInvalidRegion->Or(*aInvalidRegion, GetBounds(aBuilder, &snap));
}
nsDisplayItem::ComputeInvalidationRegion(aBuilder, aGeometry, aInvalidRegion);
}
virtual void Paint(nsDisplayListBuilder* aBuilder,
- nsRenderingContext* aCtx) override
+ gfxContext* aCtx) override
{
MOZ_ASSERT(aBuilder);
DrawTargetAutoDisableSubpixelAntialiasing disable(aCtx->GetDrawTarget(),
mDisableSubpixelAA);
DrawResult result = static_cast<nsTreeBodyFrame*>(mFrame)
->PaintTreeBody(*aCtx, mVisibleRect, ToReferenceFrame(), aBuilder);
@@ -2898,30 +2898,29 @@ nsTreeBodyFrame::BuildDisplayList(nsDisp
}
#endif
aLists.Content()->AppendNewToTop(new (aBuilder)
nsDisplayTreeBody(aBuilder, this));
}
DrawResult
-nsTreeBodyFrame::PaintTreeBody(nsRenderingContext& aRenderingContext,
+nsTreeBodyFrame::PaintTreeBody(gfxContext& aRenderingContext,
const nsRect& aDirtyRect, nsPoint aPt,
nsDisplayListBuilder* aBuilder)
{
// Update our available height and our page count.
CalcInnerBox();
DrawTarget* drawTarget = aRenderingContext.GetDrawTarget();
- gfxContext* gfx = aRenderingContext.ThebesContext();
-
- gfx->Save();
- gfx->Clip(NSRectToSnappedRect(mInnerBox + aPt,
- PresContext()->AppUnitsPerDevPixel(),
- *drawTarget));
+
+ aRenderingContext.Save();
+ aRenderingContext.Clip(
+ NSRectToSnappedRect(mInnerBox + aPt, PresContext()->AppUnitsPerDevPixel(),
+ *drawTarget));
int32_t oldPageCount = mPageLength;
if (!mHasFixedRowCount)
mPageLength = mInnerBox.height/mRowHeight;
if (oldPageCount != mPageLength || mHorzWidth != CalcHorzWidth(GetScrollParts())) {
// Schedule a ResizeReflow that will update our info properly.
PresContext()->PresShell()->
FrameNeedsReflow(this, nsIPresShell::eResize, NS_FRAME_IS_DIRTY);
@@ -2975,28 +2974,28 @@ nsTreeBodyFrame::PaintTreeBody(nsRenderi
nsRect dirtyRect;
feedbackRect += aPt;
if (dirtyRect.IntersectRect(aDirtyRect, feedbackRect)) {
result &=
PaintDropFeedback(feedbackRect, PresContext(), aRenderingContext,
aDirtyRect, aPt);
}
}
- gfx->Restore();
+ aRenderingContext.Restore();
return result;
}
DrawResult
nsTreeBodyFrame::PaintColumn(nsTreeColumn* aColumn,
const nsRect& aColumnRect,
nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
const nsRect& aDirtyRect)
{
NS_PRECONDITION(aColumn && aColumn->GetFrame(), "invalid column passed");
// Now obtain the properties for our cell.
PrefillPropertyArray(-1, aColumn);
nsAutoString properties;
mView->GetColumnProperties(aColumn, properties);
@@ -3016,17 +3015,17 @@ nsTreeBodyFrame::PaintColumn(nsTreeColum
return PaintBackgroundLayer(colContext, aPresContext, aRenderingContext,
colRect, aDirtyRect);
}
DrawResult
nsTreeBodyFrame::PaintRow(int32_t aRowIndex,
const nsRect& aRowRect,
nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
const nsRect& aDirtyRect,
nsPoint aPt,
nsDisplayListBuilder* aBuilder)
{
// We have been given a rect for our row. We treat this row like a full-blown
// frame, meaning that it can have borders, margins, padding, and a background.
// Without a view, we have no data. Check for this up front.
@@ -3058,25 +3057,25 @@ nsTreeBodyFrame::PaintRow(int32_t
DrawResult result = DrawResult::SUCCESS;
// Paint our borders and background for our row rect.
nsITheme* theme = nullptr;
auto appearance = rowContext->StyleDisplay()->mAppearance;
if (appearance) {
theme = aPresContext->GetTheme();
}
- gfxContext* ctx = aRenderingContext.ThebesContext();
+
// Save the current font smoothing background color in case we change it.
- Color originalColor(ctx->GetFontSmoothingBackgroundColor());
+ Color originalColor(aRenderingContext.GetFontSmoothingBackgroundColor());
if (theme && theme->ThemeSupportsWidget(aPresContext, nullptr, appearance)) {
nscolor color;
if (theme->WidgetProvidesFontSmoothingBackgroundColor(this, appearance,
&color)) {
// Set the font smoothing background color provided by the widget.
- ctx->SetFontSmoothingBackgroundColor(ToDeviceColor(color));
+ aRenderingContext.SetFontSmoothingBackgroundColor(ToDeviceColor(color));
}
nsRect dirty;
dirty.IntersectRect(rowRect, aDirtyRect);
theme->DrawWidgetBackground(&aRenderingContext, this, appearance, rowRect,
dirty);
} else {
result &= PaintBackgroundLayer(rowContext, aPresContext, aRenderingContext,
rowRect, aDirtyRect);
@@ -3178,28 +3177,28 @@ nsTreeBodyFrame::PaintRow(int32_t
result &= PaintCell(aRowIndex, currCol, cellRect, aPresContext,
aRenderingContext, aDirtyRect, dummy, aPt,
aBuilder);
}
}
}
// If we've changed the font smoothing background color for this row, restore
// the color to the original one.
- if (originalColor != ctx->GetFontSmoothingBackgroundColor()) {
- ctx->SetFontSmoothingBackgroundColor(originalColor);
+ if (originalColor != aRenderingContext.GetFontSmoothingBackgroundColor()) {
+ aRenderingContext.SetFontSmoothingBackgroundColor(originalColor);
}
return result;
}
DrawResult
nsTreeBodyFrame::PaintSeparator(int32_t aRowIndex,
const nsRect& aSeparatorRect,
nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
const nsRect& aDirtyRect)
{
// Resolve style for the separator.
nsStyleContext* separatorContext = GetPseudoStyleContext(nsCSSAnonBoxes::moztreeseparator);
bool useTheme = false;
nsITheme *theme = nullptr;
const nsStyleDisplay* displayData = separatorContext->StyleDisplay();
if ( displayData->mAppearance ) {
@@ -3247,17 +3246,17 @@ nsTreeBodyFrame::PaintSeparator(int32_t
return result;
}
DrawResult
nsTreeBodyFrame::PaintCell(int32_t aRowIndex,
nsTreeColumn* aColumn,
const nsRect& aCellRect,
nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
const nsRect& aDirtyRect,
nscoord& aCurrX,
nsPoint aPt,
nsDisplayListBuilder* aBuilder)
{
NS_PRECONDITION(aColumn && aColumn->GetFrame(), "invalid column passed");
// Now obtain the properties for our cell.
@@ -3323,17 +3322,17 @@ nsTreeBodyFrame::PaintCell(int32_t
nsRect twistyRect(aCellRect);
GetTwistyRect(aRowIndex, aColumn, imageSize, twistyRect, aPresContext,
twistyContext);
nsMargin twistyMargin;
twistyContext->StyleMargin()->GetMargin(twistyMargin);
twistyRect.Inflate(twistyMargin);
- aRenderingContext.ThebesContext()->Save();
+ aRenderingContext.Save();
const nsStyleBorder* borderStyle = lineContext->StyleBorder();
// Resolve currentcolor values against the treeline context
nscolor color = lineContext->StyleColor()->
CalcComplexColor(borderStyle->mBorderLeftColor);
ColorPattern colorPatt(ToDeviceColor(color));
uint8_t style = borderStyle->GetBorderStyle(eSideLeft);
@@ -3389,17 +3388,17 @@ nsTreeBodyFrame::PaintCell(int32_t
int32_t parent;
if (NS_FAILED(mView->GetParentIndex(currentParent, &parent)) || parent < 0)
break;
currentParent = parent;
srcX -= mIndentation;
}
- aRenderingContext.ThebesContext()->Restore();
+ aRenderingContext.Restore();
}
// Always leave space for the twisty.
nsRect twistyRect(currX, cellRect.y, remainingWidth, cellRect.height);
result &= PaintTwisty(aRowIndex, aColumn, twistyRect, aPresContext,
aRenderingContext, aDirtyRect, remainingWidth,
currX);
}
@@ -3456,17 +3455,17 @@ nsTreeBodyFrame::PaintCell(int32_t
return result;
}
DrawResult
nsTreeBodyFrame::PaintTwisty(int32_t aRowIndex,
nsTreeColumn* aColumn,
const nsRect& aTwistyRect,
nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
const nsRect& aDirtyRect,
nscoord& aRemainingWidth,
nscoord& aCurrX)
{
NS_PRECONDITION(aColumn && aColumn->GetFrame(), "invalid column passed");
bool isRTL = StyleVisibility()->mDirection == NS_STYLE_DIRECTION_RTL;
nscoord rightEdge = aCurrX + aRemainingWidth;
@@ -3542,32 +3541,32 @@ nsTreeBodyFrame::PaintTwisty(int32_t
// Center the image. XXX Obey vertical-align style prop?
if (imageSize.height < twistyRect.height) {
pt.y += (twistyRect.height - imageSize.height)/2;
}
// Paint the image.
result &=
nsLayoutUtils::DrawSingleUnscaledImage(
- *aRenderingContext.ThebesContext(), aPresContext, image,
+ aRenderingContext, aPresContext, image,
SamplingFilter::POINT, pt, &aDirtyRect,
imgIContainer::FLAG_NONE, &imageSize);
}
}
}
return result;
}
DrawResult
nsTreeBodyFrame::PaintImage(int32_t aRowIndex,
nsTreeColumn* aColumn,
const nsRect& aImageRect,
nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
const nsRect& aDirtyRect,
nscoord& aRemainingWidth,
nscoord& aCurrX,
nsDisplayListBuilder* aBuilder)
{
NS_PRECONDITION(aColumn && aColumn->GetFrame(), "invalid column passed");
bool isRTL = StyleVisibility()->mDirection == NS_STYLE_DIRECTION_RTL;
@@ -3703,30 +3702,29 @@ nsTreeBodyFrame::PaintImage(int32_t
// no explicit width or height attribute -- but we can still proceed and
// just treat the destination area as our whole SVG image area. Hence, we
// set wholeImageDest to the full destRect.
if (image->GetType() == imgIContainer::TYPE_VECTOR) {
wholeImageDest = destRect;
}
}
- gfxContext* ctx = aRenderingContext.ThebesContext();
if (opacity != 1.0f) {
- ctx->PushGroupForBlendBack(gfxContentType::COLOR_ALPHA, opacity);
+ aRenderingContext.PushGroupForBlendBack(gfxContentType::COLOR_ALPHA, opacity);
}
uint32_t drawFlags = aBuilder && aBuilder->IsPaintingToWindow() ?
imgIContainer::FLAG_HIGH_QUALITY_SCALING : imgIContainer::FLAG_NONE;
result &=
- nsLayoutUtils::DrawImage(*ctx, aPresContext, image,
+ nsLayoutUtils::DrawImage(aRenderingContext, aPresContext, image,
nsLayoutUtils::GetSamplingFilterForFrame(this),
wholeImageDest, destRect, destRect.TopLeft(), aDirtyRect, drawFlags);
if (opacity != 1.0f) {
- ctx->PopGroupAndBlend();
+ aRenderingContext.PopGroupAndBlend();
}
}
// Update the aRemainingWidth and aCurrX values.
imageRect.Inflate(imageMargin);
aRemainingWidth -= imageRect.width;
if (!isRTL) {
aCurrX += imageRect.width;
@@ -3742,17 +3740,17 @@ nsTreeBodyFrame::PaintImage(int32_t
#ifdef _MSC_VER
# pragma optimize("g", off)
#endif
DrawResult
nsTreeBodyFrame::PaintText(int32_t aRowIndex,
nsTreeColumn* aColumn,
const nsRect& aTextRect,
nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
const nsRect& aDirtyRect,
nscoord& aCurrX)
{
NS_PRECONDITION(aColumn && aColumn->GetFrame(), "invalid column passed");
bool isRTL = StyleVisibility()->mDirection == NS_STYLE_DIRECTION_RTL;
// Now obtain the text for our cell.
@@ -3852,43 +3850,42 @@ nsTreeBodyFrame::PaintText(int32_t
fontMet->GetStrikeout(offset, size);
nsRect r(textRect.x, textRect.y + baseline - offset, textRect.width, size);
Rect devPxRect =
NSRectToSnappedRect(r, appUnitsPerDevPixel, *drawTarget);
drawTarget->FillRect(devPxRect, color);
}
nsStyleContext* cellContext = GetPseudoStyleContext(nsCSSAnonBoxes::moztreecell);
- gfxContext* ctx = aRenderingContext.ThebesContext();
if (opacity != 1.0f) {
- ctx->PushGroupForBlendBack(gfxContentType::COLOR_ALPHA, opacity);
+ aRenderingContext.PushGroupForBlendBack(gfxContentType::COLOR_ALPHA, opacity);
}
- ctx->SetColor(Color::FromABGR(textContext->StyleColor()->mColor));
+ aRenderingContext.SetColor(Color::FromABGR(textContext->StyleColor()->mColor));
nsLayoutUtils::DrawString(this, *fontMet, &aRenderingContext, text.get(),
text.Length(),
textRect.TopLeft() + nsPoint(0, baseline),
cellContext);
if (opacity != 1.0f) {
- ctx->PopGroupAndBlend();
+ aRenderingContext.PopGroupAndBlend();
}
return result;
}
#ifdef _MSC_VER
# pragma optimize("", on)
#endif
DrawResult
nsTreeBodyFrame::PaintCheckbox(int32_t aRowIndex,
nsTreeColumn* aColumn,
const nsRect& aCheckboxRect,
nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
const nsRect& aDirtyRect)
{
NS_PRECONDITION(aColumn && aColumn->GetFrame(), "invalid column passed");
// Resolve style for the checkbox.
nsStyleContext* checkboxContext = GetPseudoStyleContext(nsCSSAnonBoxes::moztreecheckbox);
nscoord rightEdge = aCheckboxRect.XMost();
@@ -3933,31 +3930,31 @@ nsTreeBodyFrame::PaintCheckbox(int32_t
}
if (imageSize.width < checkboxRect.width) {
pt.x += (checkboxRect.width - imageSize.width)/2;
}
// Paint the image.
result &=
- nsLayoutUtils::DrawSingleUnscaledImage(*aRenderingContext.ThebesContext(),
+ nsLayoutUtils::DrawSingleUnscaledImage(aRenderingContext,
aPresContext,
image, SamplingFilter::POINT, pt, &aDirtyRect,
imgIContainer::FLAG_NONE, &imageSize);
}
return result;
}
DrawResult
nsTreeBodyFrame::PaintProgressMeter(int32_t aRowIndex,
nsTreeColumn* aColumn,
const nsRect& aProgressMeterRect,
nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
const nsRect& aDirtyRect,
nsDisplayListBuilder* aBuilder)
{
NS_PRECONDITION(aColumn && aColumn->GetFrame(), "invalid column passed");
// Resolve style for the progress meter. It contains all the info we need
// to lay ourselves out and to paint.
nsStyleContext* meterContext = GetPseudoStyleContext(nsCSSAnonBoxes::moztreeprogressmeter);
@@ -4004,17 +4001,17 @@ nsTreeBodyFrame::PaintProgressMeter(int3
int32_t width, height;
image->GetWidth(&width);
image->GetHeight(&height);
nsSize size(width*nsDeviceContext::AppUnitsPerCSSPixel(),
height*nsDeviceContext::AppUnitsPerCSSPixel());
uint32_t drawFlags = aBuilder && aBuilder->IsPaintingToWindow() ?
imgIContainer::FLAG_HIGH_QUALITY_SCALING : imgIContainer::FLAG_NONE;
result &=
- nsLayoutUtils::DrawImage(*aRenderingContext.ThebesContext(),
+ nsLayoutUtils::DrawImage(aRenderingContext,
aPresContext, image,
nsLayoutUtils::GetSamplingFilterForFrame(this),
nsRect(meterRect.TopLeft(), size), meterRect, meterRect.TopLeft(),
aDirtyRect, drawFlags);
} else {
DrawTarget* drawTarget = aRenderingContext.GetDrawTarget();
int32_t appUnitsPerDevPixel = PresContext()->AppUnitsPerDevPixel();
Rect rect =
@@ -4034,32 +4031,32 @@ nsTreeBodyFrame::PaintProgressMeter(int3
int32_t width, height;
image->GetWidth(&width);
image->GetHeight(&height);
nsSize size(width*nsDeviceContext::AppUnitsPerCSSPixel(),
height*nsDeviceContext::AppUnitsPerCSSPixel());
uint32_t drawFlags = aBuilder && aBuilder->IsPaintingToWindow() ?
imgIContainer::FLAG_HIGH_QUALITY_SCALING : imgIContainer::FLAG_NONE;
result &=
- nsLayoutUtils::DrawImage(*aRenderingContext.ThebesContext(),
+ nsLayoutUtils::DrawImage(aRenderingContext,
aPresContext, image,
nsLayoutUtils::GetSamplingFilterForFrame(this),
nsRect(meterRect.TopLeft(), size), meterRect, meterRect.TopLeft(),
aDirtyRect, drawFlags);
}
}
return result;
}
DrawResult
nsTreeBodyFrame::PaintDropFeedback(const nsRect& aDropFeedbackRect,
nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
const nsRect& aDirtyRect,
nsPoint aPt)
{
// Paint the drop feedback in between rows.
nscoord currX;
// Adjust for the primary cell.
@@ -4158,17 +4155,17 @@ nsTreeBodyFrame::PaintDropFeedback(const
}
return result;
}
DrawResult
nsTreeBodyFrame::PaintBackgroundLayer(nsStyleContext* aStyleContext,
nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
const nsRect& aRect,
const nsRect& aDirtyRect)
{
const nsStyleBorder* myBorder = aStyleContext->StyleBorder();
nsCSSRendering::PaintBGParams params =
nsCSSRendering::PaintBGParams::ForAllLayers(*aPresContext,
aDirtyRect, aRect, this,
nsCSSRendering::PAINTBG_SYNC_DECODE_IMAGES);
--- a/layout/xul/tree/nsTreeBodyFrame.h
+++ b/layout/xul/tree/nsTreeBodyFrame.h
@@ -189,17 +189,17 @@ public:
nsScrollbarFrame* mVScrollbar;
nsCOMPtr<nsIContent> mVScrollbarContent;
nsScrollbarFrame* mHScrollbar;
nsCOMPtr<nsIContent> mHScrollbarContent;
nsIFrame* mColumnsFrame;
nsIScrollableFrame* mColumnsScrollFrame;
};
- DrawResult PaintTreeBody(nsRenderingContext& aRenderingContext,
+ DrawResult PaintTreeBody(gfxContext& aRenderingContext,
const nsRect& aDirtyRect, nsPoint aPt,
nsDisplayListBuilder* aBuilder);
nsITreeBoxObject* GetTreeBoxObject() const { return mTreeBoxObject; }
// Get the base element, <tree> or <select>
nsIContent* GetBaseElement();
@@ -208,121 +208,121 @@ public:
protected:
friend class nsOverflowChecker;
// This method paints a specific column background of the tree.
DrawResult PaintColumn(nsTreeColumn* aColumn,
const nsRect& aColumnRect,
nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
const nsRect& aDirtyRect);
// This method paints a single row in the tree.
DrawResult PaintRow(int32_t aRowIndex,
const nsRect& aRowRect,
nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
const nsRect& aDirtyRect,
nsPoint aPt,
nsDisplayListBuilder* aBuilder);
// This method paints a single separator in the tree.
DrawResult PaintSeparator(int32_t aRowIndex,
const nsRect& aSeparatorRect,
nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
const nsRect& aDirtyRect);
// This method paints a specific cell in a given row of the tree.
DrawResult PaintCell(int32_t aRowIndex,
nsTreeColumn* aColumn,
const nsRect& aCellRect,
nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
const nsRect& aDirtyRect,
nscoord& aCurrX,
nsPoint aPt,
nsDisplayListBuilder* aBuilder);
// This method paints the twisty inside a cell in the primary column of an tree.
DrawResult PaintTwisty(int32_t aRowIndex,
nsTreeColumn* aColumn,
const nsRect& aTwistyRect,
nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
const nsRect& aDirtyRect,
nscoord& aRemainingWidth,
nscoord& aCurrX);
// This method paints the image inside the cell of an tree.
DrawResult PaintImage(int32_t aRowIndex,
nsTreeColumn* aColumn,
const nsRect& aImageRect,
nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
const nsRect& aDirtyRect,
nscoord& aRemainingWidth,
nscoord& aCurrX,
nsDisplayListBuilder* aBuilder);
// This method paints the text string inside a particular cell of the tree.
DrawResult PaintText(int32_t aRowIndex,
nsTreeColumn* aColumn,
const nsRect& aTextRect,
nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
const nsRect& aDirtyRect,
nscoord& aCurrX);
// This method paints the checkbox inside a particular cell of the tree.
DrawResult PaintCheckbox(int32_t aRowIndex,
nsTreeColumn* aColumn,
const nsRect& aCheckboxRect,
nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
const nsRect& aDirtyRect);
// This method paints the progress meter inside a particular cell of the tree.
DrawResult PaintProgressMeter(int32_t aRowIndex,
nsTreeColumn* aColumn,
const nsRect& aProgressMeterRect,
nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
const nsRect& aDirtyRect,
nsDisplayListBuilder* aBuilder);
// This method paints a drop feedback of the tree.
DrawResult PaintDropFeedback(const nsRect& aDropFeedbackRect,
nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
const nsRect& aDirtyRect,
nsPoint aPt);
// This method is called with a specific style context and rect to
// paint the background rect as if it were a full-blown frame.
DrawResult PaintBackgroundLayer(nsStyleContext* aStyleContext,
nsPresContext* aPresContext,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
const nsRect& aRect,
const nsRect& aDirtyRect);
// An internal hit test. aX and aY are expected to be in twips in the
// coordinate system of this frame.
int32_t GetRowAt(nscoord aX, nscoord aY);
// Check for bidi characters in the text, and if there are any, ensure
// that the prescontext is in bidi mode.
void CheckTextForBidi(nsAutoString& aText);
void AdjustForCellText(nsAutoString& aText,
int32_t aRowIndex,
nsTreeColumn* aColumn,
- nsRenderingContext& aRenderingContext,
+ gfxContext& aRenderingContext,
nsFontMetrics& aFontMetrics,
nsRect& aTextRect);
// A helper used when hit testing.
nsICSSAnonBoxPseudo* GetItemWithinCellAt(nscoord aX,
const nsRect& aCellRect,
int32_t aRowIndex,
nsTreeColumn* aColumn);
@@ -406,17 +406,17 @@ protected:
nsPoint AdjustClientCoordsToBoxCoordSpace(int32_t aX, int32_t aY);
// Cache the box object
void EnsureBoxObject();
void EnsureView();
nsresult GetCellWidth(int32_t aRow, nsTreeColumn* aCol,
- nsRenderingContext* aRenderingContext,
+ gfxContext* aRenderingContext,
nscoord& aDesiredSize, nscoord& aCurrentSize);
nscoord CalcMaxRowWidth();
// Translate the given rect horizontally from tree coordinates into the
// coordinate system of our nsTreeBodyFrame. If clip is true, then clip the
// rect to its intersection with mInnerBox in the horizontal direction.
// Return whether the result has a nonempty intersection with mInnerBox
// after projecting both onto the horizontal coordinate axis.
--- a/toolkit/components/browser/nsWebBrowser.cpp
+++ b/toolkit/components/browser/nsWebBrowser.cpp
@@ -10,16 +10,17 @@
// Helper Classes
#include "nsGfxCIID.h"
#include "nsWidgetsCID.h"
#include "gfxUtils.h"
#include "mozilla/gfx/2D.h"
// Interfaces Needed
+#include "gfxContext.h"
#include "nsReadableUtils.h"
#include "nsIComponentManager.h"
#include "nsIDOMDocument.h"
#include "nsIDOMWindow.h"
#include "nsIDOMElement.h"
#include "nsIInterfaceRequestor.h"
#include "nsIInterfaceRequestorUtils.h"
#include "nsIWebBrowserChrome.h"
@@ -32,17 +33,16 @@
#include "nsIURIContentListener.h"
#include "nsISHistoryListener.h"
#include "nsIURI.h"
#include "nsIWebBrowserPersist.h"
#include "nsCWebBrowserPersist.h"
#include "nsIServiceManager.h"
#include "nsFocusManager.h"
#include "Layers.h"
-#include "gfxContext.h"
#include "nsILoadContext.h"
#include "nsDocShell.h"
// for painting the background window
#include "mozilla/LookAndFeel.h"
// Printing Includes
#ifdef NS_PRINTING
--- a/widget/cocoa/nsDragService.mm
+++ b/widget/cocoa/nsDragService.mm
@@ -1,15 +1,16 @@
/* -*- 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 "mozilla/Logging.h"
+#include "gfxContext.h"
#include "nsArrayUtils.h"
#include "nsDragService.h"
#include "nsArrayUtils.h"
#include "nsObjCExceptions.h"
#include "nsITransferable.h"
#include "nsString.h"
#include "nsClipboard.h"
#include "nsXPCOM.h"
@@ -20,17 +21,16 @@
#include "nsIMacUtils.h"
#include "nsIDOMNode.h"
#include "nsRect.h"
#include "nsPoint.h"
#include "nsIIOService.h"
#include "nsIDocument.h"
#include "nsIContent.h"
#include "nsView.h"
-#include "gfxContext.h"
#include "nsCocoaUtils.h"
#include "mozilla/gfx/2D.h"
#include "gfxPlatform.h"
#include "nsDeviceContext.h"
using namespace mozilla;
using namespace mozilla::gfx;
--- a/widget/cocoa/nsNativeThemeCocoa.h
+++ b/widget/cocoa/nsNativeThemeCocoa.h
@@ -45,17 +45,17 @@ public:
eThemeGeometryTypeActiveSourceListSelection
};
nsNativeThemeCocoa();
NS_DECL_ISUPPORTS_INHERITED
// The nsITheme interface.
- NS_IMETHOD DrawWidgetBackground(nsRenderingContext* aContext,
+ NS_IMETHOD DrawWidgetBackground(gfxContext* aContext,
nsIFrame* aFrame,
uint8_t aWidgetType,
const nsRect& aRect,
const nsRect& aDirtyRect) override;
NS_IMETHOD GetWidgetBorder(nsDeviceContext* aContext,
nsIFrame* aFrame,
uint8_t aWidgetType,
nsIntMargin* aResult) override;
--- a/widget/cocoa/nsNativeThemeCocoa.mm
+++ b/widget/cocoa/nsNativeThemeCocoa.mm
@@ -8,17 +8,16 @@
#include "mozilla/gfx/2D.h"
#include "mozilla/gfx/Helpers.h"
#include "nsChildView.h"
#include "nsDeviceContext.h"
#include "nsLayoutUtils.h"
#include "nsObjCExceptions.h"
#include "nsNumberControlFrame.h"
#include "nsRangeFrame.h"
-#include "nsRenderingContext.h"
#include "nsRect.h"
#include "nsSize.h"
#include "nsThemeConstants.h"
#include "nsIPresShell.h"
#include "nsPresContext.h"
#include "nsIContent.h"
#include "nsIDocument.h"
#include "nsIFrame.h"
@@ -2275,17 +2274,17 @@ nsNativeThemeCocoa::IsParentScrollbarRol
static bool
IsHiDPIContext(nsPresContext* aContext)
{
return nsPresContext::AppUnitsPerCSSPixel() >=
2 * aContext->DeviceContext()->AppUnitsPerDevPixelAtUnitFullZoom();
}
NS_IMETHODIMP
-nsNativeThemeCocoa::DrawWidgetBackground(nsRenderingContext* aContext,
+nsNativeThemeCocoa::DrawWidgetBackground(gfxContext* aContext,
nsIFrame* aFrame,
uint8_t aWidgetType,
const nsRect& aRect,
const nsRect& aDirtyRect)
{
NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;
DrawTarget& aDrawTarget = *aContext->GetDrawTarget();
--- a/widget/gtk/nsNativeThemeGTK.cpp
+++ b/widget/gtk/nsNativeThemeGTK.cpp
@@ -16,17 +16,16 @@
#include "nsIContent.h"
#include "nsViewManager.h"
#include "nsNameSpaceManager.h"
#include "nsGfxCIID.h"
#include "nsTransform2D.h"
#include "nsMenuFrame.h"
#include "prlink.h"
#include "nsIDOMHTMLInputElement.h"
-#include "nsRenderingContext.h"
#include "nsGkAtoms.h"
#include "nsAttrValueInlines.h"
#include "mozilla/EventStates.h"
#include "mozilla/Services.h"
#include <gdk/gdkprivate.h>
#include <gtk/gtk.h>
@@ -1094,31 +1093,31 @@ nsNativeThemeGTK::GetExtraSizeForWidget(
aExtra->top *= scale;
aExtra->right *= scale;
aExtra->bottom *= scale;
aExtra->left *= scale;
return true;
}
NS_IMETHODIMP
-nsNativeThemeGTK::DrawWidgetBackground(nsRenderingContext* aContext,
+nsNativeThemeGTK::DrawWidgetBackground(gfxContext* aContext,
nsIFrame* aFrame,
uint8_t aWidgetType,
const nsRect& aRect,
const nsRect& aDirtyRect)
{
GtkWidgetState state;
WidgetNodeType gtkWidgetType;
GtkTextDirection direction = GetTextDirection(aFrame);
gint flags;
if (!GetGtkWidgetAndState(aWidgetType, aFrame, gtkWidgetType, &state,
&flags))
return NS_OK;
- gfxContext* ctx = aContext->ThebesContext();
+ gfxContext* ctx = aContext;
nsPresContext *presContext = aFrame->PresContext();
gfxRect rect = presContext->AppUnitsToGfxUnits(aRect);
gfxRect dirtyRect = presContext->AppUnitsToGfxUnits(aDirtyRect);
gint scaleFactor = ScreenHelperGTK::GetGTKMonitorScaleFactor();
// Align to device pixels where sensible
// to provide crisper and faster drawing.
--- a/widget/gtk/nsNativeThemeGTK.h
+++ b/widget/gtk/nsNativeThemeGTK.h
@@ -19,17 +19,17 @@ class nsNativeThemeGTK: private nsNative
public nsITheme,
public nsIObserver {
public:
NS_DECL_ISUPPORTS_INHERITED
NS_DECL_NSIOBSERVER
// The nsITheme interface.
- NS_IMETHOD DrawWidgetBackground(nsRenderingContext* aContext,
+ NS_IMETHOD DrawWidgetBackground(gfxContext* aContext,
nsIFrame* aFrame, uint8_t aWidgetType,
const nsRect& aRect,
const nsRect& aDirtyRect) override;
NS_IMETHOD GetWidgetBorder(nsDeviceContext* aContext, nsIFrame* aFrame,
uint8_t aWidgetType,
nsIntMargin* aResult) override;
--- a/widget/windows/nsDragService.cpp
+++ b/widget/windows/nsDragService.cpp
@@ -29,21 +29,21 @@
#include "nsIScreenManager.h"
#include "nsISupportsPrimitives.h"
#include "nsIURL.h"
#include "nsCWebBrowserPersist.h"
#include "nsToolkit.h"
#include "nsCRT.h"
#include "nsDirectoryServiceDefs.h"
#include "nsUnicharUtils.h"
-#include "gfxContext.h"
#include "nsRect.h"
#include "nsMathUtils.h"
#include "WinUtils.h"
#include "KeyboardLayout.h"
+#include "gfxContext.h"
#include "mozilla/gfx/2D.h"
#include "mozilla/gfx/DataSurfaceHelpers.h"
#include "mozilla/gfx/Tools.h"
using namespace mozilla;
using namespace mozilla::gfx;
using namespace mozilla::widget;
--- a/widget/windows/nsNativeThemeWin.cpp
+++ b/widget/windows/nsNativeThemeWin.cpp
@@ -4,17 +4,16 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nsNativeThemeWin.h"
#include "mozilla/EventStates.h"
#include "mozilla/Logging.h"
#include "mozilla/WindowsVersion.h"
#include "nsDeviceContext.h"
-#include "nsRenderingContext.h"
#include "nsRect.h"
#include "nsSize.h"
#include "nsTransform2D.h"
#include "nsThemeConstants.h"
#include "nsIPresShell.h"
#include "nsPresContext.h"
#include "nsIContent.h"
#include "nsIFrame.h"
@@ -1380,17 +1379,17 @@ GetThemeDpiScaleFactor(nsIFrame* aFrame)
double systemScale = WinUtils::SystemScaleFactor();
return rootWidget->GetDefaultScale().scale / systemScale;
}
}
return 1.0;
}
NS_IMETHODIMP
-nsNativeThemeWin::DrawWidgetBackground(nsRenderingContext* aContext,
+nsNativeThemeWin::DrawWidgetBackground(gfxContext* aContext,
nsIFrame* aFrame,
uint8_t aWidgetType,
const nsRect& aRect,
const nsRect& aDirtyRect)
{
HANDLE theme = GetTheme(aWidgetType);
if (!theme)
return ClassicDrawWidgetBackground(aContext, aFrame, aWidgetType, aRect, aDirtyRect);
@@ -1432,17 +1431,17 @@ nsNativeThemeWin::DrawWidgetBackground(n
nsresult rv = GetThemePartAndState(aFrame, aWidgetType, part, state);
if (NS_FAILED(rv))
return rv;
if (AssumeThemePartAndStateAreTransparent(part, state)) {
return NS_OK;
}
- RefPtr<gfxContext> ctx = aContext->ThebesContext();
+ RefPtr<gfxContext> ctx = aContext;
gfxContextMatrixAutoSaveRestore save(ctx);
double themeScale = GetThemeDpiScaleFactor(aFrame);
if (themeScale != 1.0) {
ctx->SetMatrix(ctx->CurrentMatrix().Scale(themeScale, themeScale));
}
gfxFloat p2a = gfxFloat(aFrame->PresContext()->AppUnitsPerDevPixel());
@@ -3423,17 +3422,17 @@ void nsNativeThemeWin::DrawCheckedRect(H
}
else
::FillRect(hdc, &rc, defaultBack);
::DeleteObject(patBmp);
}
}
-nsresult nsNativeThemeWin::ClassicDrawWidgetBackground(nsRenderingContext* aContext,
+nsresult nsNativeThemeWin::ClassicDrawWidgetBackground(gfxContext* aContext,
nsIFrame* aFrame,
uint8_t aWidgetType,
const nsRect& aRect,
const nsRect& aDirtyRect)
{
int32_t part, state;
bool focused;
nsresult rv;
@@ -3448,17 +3447,17 @@ nsresult nsNativeThemeWin::ClassicDrawWi
gfxFloat p2a = gfxFloat(aFrame->PresContext()->AppUnitsPerDevPixel());
RECT widgetRect;
gfxRect tr(aRect.x, aRect.y, aRect.width, aRect.height),
dr(aDirtyRect.x, aDirtyRect.y, aDirtyRect.width, aDirtyRect.height);
tr.ScaleInverse(p2a);
dr.ScaleInverse(p2a);
- RefPtr<gfxContext> ctx = aContext->ThebesContext();
+ RefPtr<gfxContext> ctx = aContext;
gfxWindowsNativeDrawing nativeDrawing(ctx, dr, GetWidgetNativeDrawingFlags(aWidgetType));
RENDER_AGAIN:
HDC hdc = nativeDrawing.BeginNativeDrawing();
if (!hdc)
return NS_ERROR_FAILURE;
--- a/widget/windows/nsNativeThemeWin.h
+++ b/widget/windows/nsNativeThemeWin.h
@@ -22,17 +22,17 @@ class nsNativeThemeWin : private nsNativ
public:
typedef mozilla::TimeStamp TimeStamp;
typedef mozilla::TimeDuration TimeDuration;
NS_DECL_ISUPPORTS_INHERITED
// The nsITheme interface.
- NS_IMETHOD DrawWidgetBackground(nsRenderingContext* aContext,
+ NS_IMETHOD DrawWidgetBackground(gfxContext* aContext,
nsIFrame* aFrame,
uint8_t aWidgetType,
const nsRect& aRect,
const nsRect& aDirtyRect) override;
NS_IMETHOD GetWidgetBorder(nsDeviceContext* aContext,
nsIFrame* aFrame,
uint8_t aWidgetType,
@@ -84,17 +84,17 @@ public:
nsNativeThemeWin();
protected:
HANDLE GetTheme(uint8_t aWidgetType);
nsresult GetThemePartAndState(nsIFrame* aFrame, uint8_t aWidgetType,
int32_t& aPart, int32_t& aState);
nsresult ClassicGetThemePartAndState(nsIFrame* aFrame, uint8_t aWidgetType,
int32_t& aPart, int32_t& aState, bool& aFocused);
- nsresult ClassicDrawWidgetBackground(nsRenderingContext* aContext,
+ nsresult ClassicDrawWidgetBackground(gfxContext* aContext,
nsIFrame* aFrame,
uint8_t aWidgetType,
const nsRect& aRect,
const nsRect& aClipRect);
nsresult ClassicGetWidgetBorder(nsDeviceContext* aContext,
nsIFrame* aFrame,
uint8_t aWidgetType,
nsIntMargin* aResult);