Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-09 11:25:00 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Backed out 8 changesets (bug 982338, bug 1057212, bug 1059033) for build bustage

Browse Source 
CLOSED TREE

Backed out changeset 4df1bd30364d (bug 982338)
Backed out changeset b68664a02904 (bug 1057212)
Backed out changeset 07b3695aa02f (bug 1059033)
Backed out changeset bb3885b57d48 (bug 1059033)
Backed out changeset 76897f52ac2c (bug 1059033)
Backed out changeset 31e89a2a409f (bug 1059033)
Backed out changeset 8e81f6f74182 (bug 1059033)
Backed out changeset c5bbf22f2f28 (bug 1059033)
This commit is contained in:
Phil Ringnalda 2014-09-01 18:07:57 -07:00
parent 0653303071
commit e63feb3849
14 changed files with 81 additions and 296 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
gfx/2d/DrawTargetCG.cpp
View File

@ -254,12 +254,7 @@ DrawTargetCG::OptimizeSourceSurface(SourceSurface *aSurface) const
aSurface->GetType() == SurfaceType::COREGRAPHICS_CGCONTEXT) {
return aSurface;
}
RefPtr<DataSourceSurface> data = aSurface->GetDataSurface();
return CreateSourceSurfaceFromData(data->GetData(),
data->GetSize(),
data->Stride(),
data->GetFormat());
return aSurface->GetDataSurface();
}
class UnboundnessFixer

237
gfx/2d/DrawTargetTiled.cpp
View File

@ -3,9 +3,6 @@
* 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/. */
#define _USE_MATH_DEFINES
#include <cmath>
#include "DrawTargetTiled.h"
#include "Logging.h"
@ -48,20 +45,66 @@ DrawTargetTiled::Init(const TileSet& aTiles)
return true;
}
class SnapshotTiled : public SourceSurface
{
public:
SnapshotTiled(const vector<Tile>& aTiles, const IntRect& aRect)
: mRect(aRect)
{
for (size_t i = 0; i < aTiles.size(); i++) {
mSnapshots.push_back(aTiles[i].mDrawTarget->Snapshot());
mOrigins.push_back(aTiles[i].mTileOrigin);
}
}
virtual SurfaceType GetType() const { return SurfaceType::TILED; }
virtual IntSize GetSize() const { return IntSize(mRect.XMost(), mRect.YMost()); }
virtual SurfaceFormat GetFormat() const { return mSnapshots[0]->GetFormat(); }
virtual TemporaryRef<DataSourceSurface> GetDataSurface()
{
RefPtr<DataSourceSurface> surf = Factory::CreateDataSourceSurface(GetSize(), GetFormat());
if (MOZ2D_WARN_IF(!surf)) {
return nullptr;
}
DataSourceSurface::MappedSurface mappedSurf;
surf->Map(DataSourceSurface::MapType::WRITE, &mappedSurf);
{
RefPtr<DrawTarget> dt =
Factory::CreateDrawTargetForData(BackendType::CAIRO, mappedSurf.mData,
GetSize(), mappedSurf.mStride, GetFormat());
for (size_t i = 0; i < mSnapshots.size(); i++) {
RefPtr<DataSourceSurface> dataSurf = mSnapshots[i]->GetDataSurface();
dt->CopySurface(dataSurf, IntRect(IntPoint(0, 0), mSnapshots[i]->GetSize()), mOrigins[i]);
}
}
surf->Unmap();
return surf.forget();
}
private:
vector<RefPtr<SourceSurface>> mSnapshots;
vector<IntPoint> mOrigins;
IntRect mRect;
};
TemporaryRef<SourceSurface>
DrawTargetTiled::Snapshot()
{
return new SnapshotTiled(mTiles, mRect);
}
// Skip the mClippedOut check since this is only used for Flush() which
// should happen even if we're clipped.
#define TILED_COMMAND(command) \
void \
DrawTargetTiled::command() \
{ \
for (size_t i = 0; i < mTiles.size(); i++) { \
mTiles[i].mDrawTarget->command(); \
\
\
mTiles[i].mDrawTarget->command(); \
} \
}
#define TILED_COMMAND1(command, type1) \
@ -69,8 +112,9 @@ DrawTargetTiled::Snapshot()
DrawTargetTiled::command(type1 arg1) \
{ \
for (size_t i = 0; i < mTiles.size(); i++) { \
if (!mTiles[i].mClippedOut) \
mTiles[i].mDrawTarget->command(arg1); \
\
\
mTiles[i].mDrawTarget->command(arg1); \
} \
}
#define TILED_COMMAND3(command, type1, type2, type3) \
@ -78,8 +122,9 @@ DrawTargetTiled::Snapshot()
DrawTargetTiled::command(type1 arg1, type2 arg2, type3 arg3) \
{ \
for (size_t i = 0; i < mTiles.size(); i++) { \
if (!mTiles[i].mClippedOut) \
mTiles[i].mDrawTarget->command(arg1, arg2, arg3); \
\
\
mTiles[i].mDrawTarget->command(arg1, arg2, arg3); \
} \
}
#define TILED_COMMAND4(command, type1, type2, type3, type4) \
@ -87,8 +132,9 @@ DrawTargetTiled::Snapshot()
DrawTargetTiled::command(type1 arg1, type2 arg2, type3 arg3, type4 arg4) \
{ \
for (size_t i = 0; i < mTiles.size(); i++) { \
if (!mTiles[i].mClippedOut) \
mTiles[i].mDrawTarget->command(arg1, arg2, arg3, arg4); \
\
\
mTiles[i].mDrawTarget->command(arg1, arg2, arg3, arg4); \
} \
}
#define TILED_COMMAND5(command, type1, type2, type3, type4, type5) \
@ -96,82 +142,29 @@ DrawTargetTiled::Snapshot()
DrawTargetTiled::command(type1 arg1, type2 arg2, type3 arg3, type4 arg4, type5 arg5) \
{ \
for (size_t i = 0; i < mTiles.size(); i++) { \
if (!mTiles[i].mClippedOut) \
mTiles[i].mDrawTarget->command(arg1, arg2, arg3, arg4, arg5); \
\
\
mTiles[i].mDrawTarget->command(arg1, arg2, arg3, arg4, arg5); \
} \
}
TILED_COMMAND(Flush)
TILED_COMMAND5(DrawSurface, SourceSurface*, const Rect&,
const Rect&, const DrawSurfaceOptions&,
const DrawOptions&)
TILED_COMMAND4(DrawFilter, FilterNode*, const Rect&, const Point&, const DrawOptions&)
TILED_COMMAND1(ClearRect, const Rect&)
TILED_COMMAND4(MaskSurface, const Pattern&, SourceSurface*, Point, const DrawOptions&)
TILED_COMMAND3(FillRect, const Rect&, const Pattern&, const DrawOptions&)
TILED_COMMAND4(StrokeRect, const Rect&, const Pattern&, const StrokeOptions&, const DrawOptions&)
TILED_COMMAND5(StrokeLine, const Point&, const Point&, const Pattern&, const StrokeOptions&, const DrawOptions&)
TILED_COMMAND4(Stroke, const Path*, const Pattern&, const StrokeOptions&, const DrawOptions&)
TILED_COMMAND3(Fill, const Path*, const Pattern&, const DrawOptions&)
TILED_COMMAND5(FillGlyphs, ScaledFont*, const GlyphBuffer&, const Pattern&, const DrawOptions&, const GlyphRenderingOptions*)
TILED_COMMAND3(Mask, const Pattern&, const Pattern&, const DrawOptions&)
void
DrawTargetTiled::PushClip(const Path* aPath)
{
mClippedOutTilesStack.push_back(std::vector<uint32_t>());
std::vector<uint32_t>& clippedTiles = mClippedOutTilesStack.back();
Rect deviceRect = aPath->GetBounds(mTransform);
for (size_t i = 0; i < mTiles.size(); i++) {
if (!mTiles[i].mClippedOut) {
if (deviceRect.Intersects(Rect(mTiles[i].mTileOrigin.x,
mTiles[i].mTileOrigin.y,
mTiles[i].mDrawTarget->GetSize().width,
mTiles[i].mDrawTarget->GetSize().height))) {
mTiles[i].mDrawTarget->PushClip(aPath);
} else {
mTiles[i].mClippedOut = true;
clippedTiles.push_back(i);
}
}
}
}
void
DrawTargetTiled::PushClipRect(const Rect& aRect)
{
mClippedOutTilesStack.push_back(std::vector<uint32_t>());
std::vector<uint32_t>& clippedTiles = mClippedOutTilesStack.back();
Rect deviceRect = mTransform.TransformBounds(aRect);
for (size_t i = 0; i < mTiles.size(); i++) {
if (!mTiles[i].mClippedOut) {
if (deviceRect.Intersects(Rect(mTiles[i].mTileOrigin.x,
mTiles[i].mTileOrigin.y,
mTiles[i].mDrawTarget->GetSize().width,
mTiles[i].mDrawTarget->GetSize().height))) {
mTiles[i].mDrawTarget->PushClipRect(aRect);
} else {
mTiles[i].mClippedOut = true;
clippedTiles.push_back(i);
}
}
}
}
void
DrawTargetTiled::PopClip()
{
for (size_t i = 0; i < mTiles.size(); i++) {
if (!mTiles[i].mClippedOut) {
mTiles[i].mDrawTarget->PopClip();
}
}
std::vector<uint32_t>& clippedTiles = mClippedOutTilesStack.back();
for (size_t i = 0; i < clippedTiles.size(); i++) {
mTiles[clippedTiles[i]].mClippedOut = false;
}
mClippedOutTilesStack.pop_back();
}
TILED_COMMAND1(PushClip, const Path*)
TILED_COMMAND1(PushClipRect, const Rect&)
TILED_COMMAND(PopClip)
void
DrawTargetTiled::CopySurface(SourceSurface *aSurface,
@ -205,95 +198,5 @@ DrawTargetTiled::SetTransform(const Matrix& aTransform)
DrawTarget::SetTransform(aTransform);
}
void
DrawTargetTiled::DrawSurface(SourceSurface* aSurface, const Rect& aDest, const Rect& aSource, const DrawSurfaceOptions& aSurfaceOptions, const DrawOptions& aDrawOptions)
{
Rect deviceRect = mTransform.TransformBounds(aDest);
for (size_t i = 0; i < mTiles.size(); i++) {
if (!mTiles[i].mClippedOut &&
deviceRect.Intersects(Rect(mTiles[i].mTileOrigin.x,
mTiles[i].mTileOrigin.y,
mTiles[i].mDrawTarget->GetSize().width,
mTiles[i].mDrawTarget->GetSize().height))) {
mTiles[i].mDrawTarget->DrawSurface(aSurface, aDest, aSource, aSurfaceOptions, aDrawOptions);
}
}
}
void
DrawTargetTiled::FillRect(const Rect& aRect, const Pattern& aPattern, const DrawOptions& aDrawOptions)
{
Rect deviceRect = mTransform.TransformBounds(aRect);
for (size_t i = 0; i < mTiles.size(); i++) {
if (!mTiles[i].mClippedOut &&
deviceRect.Intersects(Rect(mTiles[i].mTileOrigin.x,
mTiles[i].mTileOrigin.y,
mTiles[i].mDrawTarget->GetSize().width,
mTiles[i].mDrawTarget->GetSize().height))) {
mTiles[i].mDrawTarget->FillRect(aRect, aPattern, aDrawOptions);
}
}
}
// The logic for this comes from _cairo_stroke_style_max_distance_from_path
static Rect
PathExtentsToMaxStrokeExtents(const StrokeOptions &aStrokeOptions,
const Rect &aRect,
const Matrix &aTransform)
{
double styleExpansionFactor = 0.5f;
if (aStrokeOptions.mLineCap == CapStyle::SQUARE) {
styleExpansionFactor = M_SQRT1_2;
}
if (aStrokeOptions.mLineJoin == JoinStyle::MITER &&
styleExpansionFactor < M_SQRT2 * aStrokeOptions.mMiterLimit) {
styleExpansionFactor = M_SQRT2 * aStrokeOptions.mMiterLimit;
}
styleExpansionFactor *= aStrokeOptions.mLineWidth;
double dx = styleExpansionFactor * hypot(aTransform._11, aTransform._21);
double dy = styleExpansionFactor * hypot(aTransform._22, aTransform._12);
Rect result = aRect;
result.Inflate(dx, dy);
return result;
}
void
DrawTargetTiled::Stroke(const Path* aPath, const Pattern& aPattern, const StrokeOptions& aStrokeOptions, const DrawOptions& aDrawOptions)
{
// Approximate the stroke extents, since Path::GetStrokeExtents can be slow
Rect deviceRect = PathExtentsToMaxStrokeExtents(aStrokeOptions,
aPath->GetBounds(mTransform),
mTransform);
for (size_t i = 0; i < mTiles.size(); i++) {
if (!mTiles[i].mClippedOut &&
deviceRect.Intersects(Rect(mTiles[i].mTileOrigin.x,
mTiles[i].mTileOrigin.y,
mTiles[i].mDrawTarget->GetSize().width,
mTiles[i].mDrawTarget->GetSize().height))) {
mTiles[i].mDrawTarget->Stroke(aPath, aPattern, aStrokeOptions, aDrawOptions);
}
}
}
void
DrawTargetTiled::Fill(const Path* aPath, const Pattern& aPattern, const DrawOptions& aDrawOptions)
{
Rect deviceRect = aPath->GetBounds(mTransform);
for (size_t i = 0; i < mTiles.size(); i++) {
if (!mTiles[i].mClippedOut &&
deviceRect.Intersects(Rect(mTiles[i].mTileOrigin.x,
mTiles[i].mTileOrigin.y,
mTiles[i].mDrawTarget->GetSize().width,
mTiles[i].mDrawTarget->GetSize().height))) {
mTiles[i].mDrawTarget->Fill(aPath, aPattern, aDrawOptions);
}
}
}
}
}

60
gfx/2d/DrawTargetTiled.h
View File

@ -14,20 +14,6 @@
namespace mozilla {
namespace gfx {
struct TileInternal : public Tile {
TileInternal()
: mClippedOut(false)
{}
TileInternal(const Tile& aOther)
: Tile(aOther)
, mClippedOut(false)
{}
bool mClippedOut;
};
class DrawTargetTiled : public DrawTarget
{
public:
@ -144,51 +130,7 @@ public:
}
private:
std::vector<TileInternal> mTiles;
std::vector<std::vector<uint32_t> > mClippedOutTilesStack;
IntRect mRect;
};
class SnapshotTiled : public SourceSurface
{
public:
SnapshotTiled(const std::vector<TileInternal>& aTiles, const IntRect& aRect)
: mRect(aRect)
{
for (size_t i = 0; i < aTiles.size(); i++) {
mSnapshots.push_back(aTiles[i].mDrawTarget->Snapshot());
mOrigins.push_back(aTiles[i].mTileOrigin);
}
}
virtual SurfaceType GetType() const { return SurfaceType::TILED; }
virtual IntSize GetSize() const { return IntSize(mRect.XMost(), mRect.YMost()); }
virtual SurfaceFormat GetFormat() const { return mSnapshots[0]->GetFormat(); }
virtual TemporaryRef<DataSourceSurface> GetDataSurface()
{
RefPtr<DataSourceSurface> surf = Factory::CreateDataSourceSurface(GetSize(), GetFormat());
DataSourceSurface::MappedSurface mappedSurf;
surf->Map(DataSourceSurface::MapType::WRITE, &mappedSurf);
{
RefPtr<DrawTarget> dt =
Factory::CreateDrawTargetForData(BackendType::CAIRO, mappedSurf.mData,
GetSize(), mappedSurf.mStride, GetFormat());
for (size_t i = 0; i < mSnapshots.size(); i++) {
RefPtr<DataSourceSurface> dataSurf = mSnapshots[i]->GetDataSurface();
dt->CopySurface(dataSurf, IntRect(IntPoint(0, 0), mSnapshots[i]->GetSize()), mOrigins[i]);
}
}
surf->Unmap();
return surf.forget();
}
std::vector<RefPtr<SourceSurface>> mSnapshots;
std::vector<IntPoint> mOrigins;
std::vector<Tile> mTiles;
IntRect mRect;
};

6
gfx/2d/moz.build
View File

@ -21,7 +21,6 @@ EXPORTS.mozilla.gfx += [
'BorrowedContext.h',
'Coord.h',
'DataSurfaceHelpers.h',
'DrawTargetTiled.h',
'Filters.h',
'Helpers.h',
'Logging.h',
@ -108,6 +107,7 @@ UNIFIED_SOURCES += [
'DrawTargetCapture.cpp',
'DrawTargetDual.cpp',
'DrawTargetRecording.cpp',
'DrawTargetTiled.cpp',
'Factory.cpp',
'FilterNodeSoftware.cpp',
'FilterProcessing.cpp',
@ -126,10 +126,6 @@ UNIFIED_SOURCES += [
'SourceSurfaceRawData.cpp',
]
SOURCES += [
'DrawTargetTiled.cpp',
]
if CONFIG['MOZ_WIDGET_TOOLKIT'] == 'cocoa':
SOURCES += [
'MacIOSurface.cpp',

2
gfx/layers/client/ClientThebesLayer.cpp
View File

@ -163,7 +163,7 @@ ClientLayerManager::CreateThebesLayerWithHint(ThebesLayerCreationHint aHint)
#ifdef MOZ_B2G
aHint == SCROLLABLE &&
#endif
gfxPlatform::GetPlatform()->UseTiling() &&
gfxPrefs::LayersTilesEnabled() &&
(AsShadowForwarder()->GetCompositorBackendType() == LayersBackend::LAYERS_OPENGL ||
AsShadowForwarder()->GetCompositorBackendType() == LayersBackend::LAYERS_D3D9 ||
AsShadowForwarder()->GetCompositorBackendType() == LayersBackend::LAYERS_D3D11)) {

2
gfx/layers/client/TextureClient.cpp
View File

@ -689,7 +689,6 @@ BufferTextureClient::BorrowDrawTarget()
MOZ_ASSERT(mLocked, "BorrowDrawTarget should be called on locked textures only");
if (mDrawTarget) {
mDrawTarget->SetTransform(Matrix());
return mDrawTarget;
}
@ -739,6 +738,7 @@ BufferTextureClient::Unlock()
}
mDrawTarget->Flush();
mDrawTarget = nullptr;
}
bool

29
gfx/thebes/gfxContext.cpp
View File

@ -24,7 +24,6 @@
#include "GeckoProfiler.h"
#include "gfx2DGlue.h"
#include "mozilla/gfx/PathHelpers.h"
#include "mozilla/gfx/DrawTargetTiled.h"
#include <algorithm>
#if CAIRO_HAS_DWRITE_FONT
@ -1119,32 +1118,12 @@ gfxContext::PushGroupAndCopyBackground(gfxContentType content)
Point offset = CurrentState().deviceOffset - oldDeviceOffset;
Rect surfRect(0, 0, Float(mDT->GetSize().width), Float(mDT->GetSize().height));
Rect sourceRect = surfRect + offset;
Rect sourceRect = surfRect;
sourceRect.x += offset.x;
sourceRect.y += offset.y;
mDT->SetTransform(Matrix());
// XXX: It's really sad that we have to do this (for performance).
// Once DrawTarget gets a PushLayer API we can implement this within
// DrawTargetTiled.
if (source->GetType() == SurfaceType::TILED) {
SnapshotTiled *sourceTiled = static_cast<SnapshotTiled*>(source.get());
for (uint32_t i = 0; i < sourceTiled->mSnapshots.size(); i++) {
Rect tileSourceRect = sourceRect.Intersect(Rect(sourceTiled->mOrigins[i].x,
sourceTiled->mOrigins[i].y,
sourceTiled->mSnapshots[i]->GetSize().width,
sourceTiled->mSnapshots[i]->GetSize().height));
if (tileSourceRect.IsEmpty()) {
continue;
}
Rect tileDestRect = tileSourceRect - offset;
tileSourceRect -= sourceTiled->mOrigins[i];
mDT->DrawSurface(sourceTiled->mSnapshots[i], tileDestRect, tileSourceRect);
}
} else {
mDT->DrawSurface(source, surfRect, sourceRect);
}
mDT->DrawSurface(source, surfRect, sourceRect);
mDT->SetOpaqueRect(oldDT->GetOpaqueRect());
PushClipsToDT(mDT);

2
gfx/thebes/gfxPlatform.h
View File

@ -252,8 +252,6 @@ public:
virtual bool UseAcceleratedSkiaCanvas();
virtual void InitializeSkiaCacheLimits();
virtual bool UseTiling() { return gfxPrefs::LayersTilesEnabled(); }
void GetAzureBackendInfo(mozilla::widget::InfoObject &aObj) {
aObj.DefineProperty("AzureCanvasBackend", GetBackendName(mPreferredCanvasBackend));
aObj.DefineProperty("AzureSkiaAccelerated", UseAcceleratedSkiaCanvas());

11
gfx/thebes/gfxPlatformMac.cpp
View File

@ -18,7 +18,6 @@
#include "mozilla/Preferences.h"
#include "qcms.h"
#include "gfx2DGlue.h"
#include "gfxPrefs.h"
#include <dlfcn.h>
@ -387,16 +386,6 @@ gfxPlatformMac::UseAcceleratedCanvas()
return nsCocoaFeatures::OnLionOrLater() && Preferences::GetBool("gfx.canvas.azure.accelerated", false);
}
bool
gfxPlatformMac::UseTiling()
{
if (gfxPrefs::LayersTilesForceEnabled()) {
return true;
}
// Tiling seems to be slow on 10.6 so disable it until we figure it out
return nsCocoaFeatures::OnLionOrLater() && gfxPlatform::UseTiling();
}
void
gfxPlatformMac::GetPlatformCMSOutputProfile(void* &mem, size_t &size)
{

2
gfx/thebes/gfxPlatformMac.h
View File

@ -61,8 +61,6 @@ public:
bool UseAcceleratedCanvas();
virtual bool UseTiling() MOZ_OVERRIDE;
// lower threshold on font anti-aliasing
uint32_t GetAntiAliasingThreshold() { return mFontAntiAliasingThreshold; }

1
gfx/thebes/gfxPrefs.h
View File

@ -237,7 +237,6 @@ private:
DECL_GFX_PREF(Live, "layers.effect.invert", LayersEffectInvert, bool, false);
DECL_GFX_PREF(Once, "layers.enable-tiles", LayersTilesEnabled, bool, false);
DECL_GFX_PREF(Once, "layers.force-enable-tiles", LayersTilesForceEnabled, bool, false);
DECL_GFX_PREF(Once, "layers.simple-tiles", LayersUseSimpleTiles, bool, false);
DECL_GFX_PREF(Once, "layers.force-per-tile-drawing", PerTileDrawing, bool, false);
DECL_GFX_PREF(Once, "layers.tiled-drawtarget.enabled", TiledDrawTargetEnabled, bool, false);

14
layout/generic/nsTextFrame.cpp
View File

@ -4570,20 +4570,8 @@ nsDisplayText::Paint(nsDisplayListBuilder* aBuilder,
extraVisible.Inflate(appUnitsPerDevPixel, appUnitsPerDevPixel);
nsTextFrame* f = static_cast<nsTextFrame*>(mFrame);
gfxContext* ctx = aCtx->ThebesContext();
gfxContextAutoDisableSubpixelAntialiasing disable(ctx,
gfxContextAutoDisableSubpixelAntialiasing disable(aCtx->ThebesContext(),
mDisableSubpixelAA);
gfxContextAutoSaveRestore save(ctx);
gfxRect pixelVisible =
nsLayoutUtils::RectToGfxRect(extraVisible, appUnitsPerDevPixel);
pixelBounds.Inflate(2);
pixelBounds.RoundOut();
ctx->NewPath();
ctx->Rectangle(pixelVisible);
ctx->Clip();
NS_ASSERTION(mLeftEdge >= 0, "illegal left edge");
NS_ASSERTION(mRightEdge >= 0, "illegal right edge");
f->PaintText(aCtx, ToReferenceFrame(), extraVisible, *this);

2
layout/reftests/scrolling/reftest.list
View File

@ -1,6 +1,6 @@
skip-if(B2G&&browserIsRemote) HTTP == deferred-anchor.xhtml#d deferred-anchor-ref.xhtml#d
== deferred-anchor2.xhtml deferred-anchor-ref.xhtml#d
ffuzzy-if(/^Windows\x20NT\x206\.2/.test(http.oscpu),1,4) HTTP == fixed-1.html fixed-1.html?ref
HTTP == fixed-1.html fixed-1.html?ref
HTTP == fixed-opacity-1.html fixed-opacity-1.html?ref
skip-if(B2G) HTTP == fixed-opacity-2.html fixed-opacity-2.html?ref
skip-if(B2G) random-if(gtk2Widget) fuzzy-if(Android,3,60) HTTP == fixed-text-1.html fixed-text-1.html?ref

2
modules/libpref/init/all.js
View File

@ -3826,8 +3826,6 @@ pref("layers.offmainthreadcomposition.enabled", true);
#ifdef XP_MACOSX
pref("layers.offmainthreadcomposition.enabled", true);
pref("layers.enable-tiles", true);
pref("layers.tiled-drawtarget.enabled", true);
#endif
// ANDROID covers android and b2g