Backed out 2 changesets (bug 1309200) for build bustage on a CLOSED TREE a=backout
authorWes Kocher <wkocher@mozilla.com>
Fri, 28 Oct 2016 10:22:47 -0700
changeset 320030 6f5c85e2f3f886f42a53fc926e265b476b642ea7
parent 320029 c2b8b8480075a26f7caeb6d2f4d49779a9632aa7
child 320031 4f43fa0be4394873392d847d78d2a20d01482f0d
push id20749
push userryanvm@gmail.com
push dateSat, 29 Oct 2016 13:21:21 +0000
treeherderfx-team@1b170b39ed6b [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersbackout
bugs1309200
milestone52.0a1
backs outb5ad7d04ed432709e739174b6f9671e2945b973c
1563a66b64d8791070bd6b6317187d76533a1466
Backed out 2 changesets (bug 1309200) for build bustage on a CLOSED TREE a=backout Backed out changeset b5ad7d04ed43 (bug 1309200) Backed out changeset 1563a66b64d8 (bug 1309200)
gfx/2d/2D.h
gfx/2d/Factory.cpp
gfx/ipc/GPUParent.cpp
gfx/thebes/gfxPlatform.cpp
gfx/thebes/gfxPlatform.h
--- a/gfx/2d/2D.h
+++ b/gfx/2d/2D.h
@@ -1291,23 +1291,21 @@ struct TileSet
   Tile* mTiles;
   size_t mTileCount;
 };
 
 struct Config {
   LogForwarder* mLogForwarder;
   int32_t mMaxTextureSize;
   int32_t mMaxAllocSize;
-  BackendType mDefaultSoftwareBackend;
 
   Config()
   : mLogForwarder(nullptr)
   , mMaxTextureSize(8192)
   , mMaxAllocSize(52000000)
-  , mDefaultSoftwareBackend(BackendType::CAIRO)
   {}
 };
 
 class GFX2D_API Factory
 {
 public:
   static void Init(const Config& aConfig);
   static void ShutDown();
@@ -1435,18 +1433,16 @@ public:
 
   static already_AddRefed<DrawEventRecorder>
     CreateEventRecorderForFile(const char *aFilename);
 
   static void SetGlobalEventRecorder(DrawEventRecorder *aRecorder);
 
   static uint32_t GetMaxSurfaceSize(BackendType aType);
 
-  static BackendType GetDefaultSoftwareBackend();
-
   static LogForwarder* GetLogForwarder() { return sConfig ? sConfig->mLogForwarder : nullptr; }
 
 private:
   static Config* sConfig;
 public:
 
 #ifdef USE_SKIA_GPU
   static already_AddRefed<DrawTarget>
--- a/gfx/2d/Factory.cpp
+++ b/gfx/2d/Factory.cpp
@@ -212,22 +212,16 @@ Factory::HasSSE2()
     sDetectionState = HasCPUIDBit(1u, edx, (1u<<26)) ? HAS_SSE2 : NO_SSE2;
   }
   return sDetectionState == HAS_SSE2;
 #else
   return false;
 #endif
 }
 
-BackendType
-Factory::GetDefaultSoftwareBackend()
-{
-  return sConfig ? sConfig->mDefaultSoftwareBackend : BackendType::CAIRO;
-}
-
 // If the size is "reasonable", we want gfxCriticalError to assert, so
 // this is the option set up for it.
 inline int LoggerOptionsBasedOnSize(const IntSize& aSize)
 {
   return CriticalLog::DefaultOptions(Factory::ReasonableSurfaceSize(aSize));
 }
 
 bool
--- a/gfx/ipc/GPUParent.cpp
+++ b/gfx/ipc/GPUParent.cpp
@@ -87,17 +87,17 @@ GPUParent::Init(base::ProcessId aParentP
 #endif
 
   // Ensure gfxPrefs are initialized.
   gfxPrefs::GetSingleton();
   gfxConfig::Init();
   gfxVars::Initialize();
   gfxPlatform::InitNullMetadata();
   // Ensure our Factory is initialised, mainly for gfx logging to work.
-  gfxPlatform::InitMoz2D();
+  gfxPlatform::InitMoz2DLogging();
 #if defined(XP_WIN)
   DeviceManagerDx::Init();
   DeviceManagerD3D9::Init();
 #endif
   if (NS_FAILED(NS_InitMinimalXPCOM())) {
     return false;
   }
   CompositorThreadHolder::Start();
--- a/gfx/thebes/gfxPlatform.cpp
+++ b/gfx/thebes/gfxPlatform.cpp
@@ -648,17 +648,17 @@ gfxPlatform::Init()
       forcedPrefs.AppendPrintf("-T%d%d%d%d) ",
                                gfxPrefs::AndroidRGB16Force(),
                                gfxPrefs::CanvasAzureAccelerated(),
                                gfxPrefs::DisableGralloc(),
                                gfxPrefs::ForceShmemTiles());
       ScopedGfxFeatureReporter::AppNote(forcedPrefs);
     }
 
-    InitMoz2D();
+    InitMoz2DLogging();
 
     gGfxPlatformPrefsLock = new Mutex("gfxPlatform::gGfxPlatformPrefsLock");
 
     /* Initialize the GfxInfo service.
      * Note: we can't call functions on GfxInfo that depend
      * on gPlatform until after it has been initialized
      * below. GfxInfo initialization annotates our
      * crash reports so we want to do it before
@@ -788,26 +788,25 @@ gfxPlatform::Init()
     InitOpenGLConfig();
 
     if (obs) {
       obs->NotifyObservers(nullptr, "gfx-features-ready", nullptr);
     }
 }
 
 /* static */ void
-gfxPlatform::InitMoz2D()
+gfxPlatform::InitMoz2DLogging()
 {
     auto fwd = new CrashStatsLogForwarder("GraphicsCriticalError");
     fwd->SetCircularBufferSize(gfxPrefs::GfxLoggingCrashLength());
 
     mozilla::gfx::Config cfg;
     cfg.mLogForwarder = fwd;
     cfg.mMaxTextureSize = gfxPrefs::MaxTextureSize();
     cfg.mMaxAllocSize = gfxPrefs::MaxAllocSize();
-    cfg.mDefaultSoftwareBackend = gPlatform->GetSoftwareBackend();
 
     gfx::Factory::Init(cfg);
 }
 
 static bool sLayersIPCIsUp = false;
 
 /* static */ void
 gfxPlatform::InitNullMetadata()
@@ -1628,31 +1627,26 @@ gfxPlatform::InitBackendPrefs(uint32_t a
       mFallbackCanvasBackend =
           GetCanvasBackendPref(aCanvasBitmask &
                                ~(BackendTypeBit(mPreferredCanvasBackend) | BackendTypeBit(BackendType::DIRECT2D)));
     } else {
       mFallbackCanvasBackend =
           GetCanvasBackendPref(aCanvasBitmask & ~BackendTypeBit(mPreferredCanvasBackend));
     }
 
-
     mContentBackendBitmask = aContentBitmask;
     mContentBackend = GetContentBackendPref(mContentBackendBitmask);
     if (mContentBackend == BackendType::NONE) {
         mContentBackend = aContentDefault;
         // mContentBackendBitmask is our canonical reference for supported
         // backends so we need to add the default if we are using it and
         // overriding the prefs.
         mContentBackendBitmask |= BackendTypeBit(aContentDefault);
     }
 
-    uint32_t swBackendBits = BackendTypeBit(BackendType::SKIA) |
-                             BackendTypeBit(BackendType::CAIRO);
-    mSoftwareBackend = GetContentBackendPref(swBackendBits);
-
     if (XRE_IsParentProcess()) {
         gfxVars::SetContentBackend(mContentBackend);
     }
 }
 
 /* static */ BackendType
 gfxPlatform::GetCanvasBackendPref(uint32_t aBackendBitmask)
 {
--- a/gfx/thebes/gfxPlatform.h
+++ b/gfx/thebes/gfxPlatform.h
@@ -173,17 +173,17 @@ public:
     static void InitLayersIPC();
     static void ShutdownLayersIPC();
 
     /**
      * Initialize ScrollMetadata statics. Does not depend on gfxPlatform.
      */
     static void InitNullMetadata();
 
-    static void InitMoz2D();
+    static void InitMoz2DLogging();
 
     /**
      * Create an offscreen surface of the given dimensions
      * and image format.
      */
     virtual already_AddRefed<gfxASurface>
       CreateOffscreenSurface(const IntSize& aSize,
                              gfxImageFormat aFormat) = 0;
@@ -285,21 +285,16 @@ public:
 
     // Get the default content backend that will be used with the default
     // compositor. If the compositor is known when calling this function,
     // GetContentBackendFor() should be called instead.
     mozilla::gfx::BackendType GetDefaultContentBackend() {
       return mContentBackend;
     }
 
-    /// Return the software backend to use by default.
-    mozilla::gfx::BackendType GetSoftwareBackend() {
-        return mSoftwareBackend;
-    }
-
     // Return the best content backend available that is compatible with the
     // given layers backend.
     virtual mozilla::gfx::BackendType GetContentBackendFor(mozilla::layers::LayersBackend aLayers) {
       return mContentBackend;
     }
 
     mozilla::gfx::BackendType GetPreferredCanvasBackend() {
       return mPreferredCanvasBackend;
@@ -817,18 +812,16 @@ private:
     nsCOMPtr<nsIObserver> mMemoryPressureObserver;
 
     // The preferred draw target backend to use for canvas
     mozilla::gfx::BackendType mPreferredCanvasBackend;
     // The fallback draw target backend to use for canvas, if the preferred backend fails
     mozilla::gfx::BackendType mFallbackCanvasBackend;
     // The backend to use for content
     mozilla::gfx::BackendType mContentBackend;
-    // The backend to use when we need it not to be accelerated.
-    mozilla::gfx::BackendType mSoftwareBackend;
     // Bitmask of backend types we can use to render content
     uint32_t mContentBackendBitmask;
 
     mozilla::widget::GfxInfoCollector<gfxPlatform> mAzureCanvasBackendCollector;
     mozilla::widget::GfxInfoCollector<gfxPlatform> mApzSupportCollector;
     mozilla::widget::GfxInfoCollector<gfxPlatform> mTilesInfoCollector;
 
     RefPtr<mozilla::gfx::DrawEventRecorder> mRecorder;