--- a/layout/base/FrameLayerBuilder.cpp
+++ b/layout/base/FrameLayerBuilder.cpp
@@ -1522,103 +1522,92 @@ struct MaskLayerUserData : public LayerU
   nsTArray<DisplayItemClip::RoundedRect> mRoundedClipRects;
   // scale from the masked layer which is applied to the mask
   float mScaleX, mScaleY;
   // The ContainerLayerParameters offset which is applied to the mask's transform.
   nsIntPoint mOffset;
   int32_t mAppUnitsPerDevPixel;
 };
 
-class MaskImageData
+MaskImageData::MaskImageData(const gfx::IntSize& aSize, LayerManager* aLayerManager)
+  : mTextureClientLocked(false)
+  , mSize(aSize)
+  , mLayerManager(aLayerManager)
+{
+}
+
+MaskImageData::~MaskImageData()
+{
+  if (mTextureClientLocked) {
+    MOZ_ASSERT(mTextureClient);
+    // Clear DrawTarget before Unlock.
+    mDrawTarget = nullptr;
+    mTextureClient->Unlock();
+  }
+}
+
+gfx::DrawTarget* MaskImageData::CreateDrawTarget()
 {
-public:
-  MaskImageData(const gfx::IntSize& aSize, LayerManager* aLayerManager)
-    : mTextureClientLocked(false)
-    , mSize(aSize)
-    , mLayerManager(aLayerManager)
-  {
-  }
-
-  ~MaskImageData()
-  {
-    if (mTextureClientLocked) {
-      MOZ_ASSERT(mTextureClient);
-      // Clear DrawTarget before Unlock.
-      mDrawTarget = nullptr;
-      mTextureClient->Unlock();
-    }
-  }
-
-  gfx::DrawTarget* CreateDrawTarget()
-  {
-    MOZ_ASSERT(mLayerManager);
-    if (mDrawTarget) {
-      return mDrawTarget;
-    }
-
-    if (mLayerManager->GetBackendType() == LayersBackend::LAYERS_BASIC) {
-      mDrawTarget = mLayerManager->CreateOptimalMaskDrawTarget(mSize);
-      return mDrawTarget;
-    }
-
-    MOZ_ASSERT(mLayerManager->GetBackendType() == LayersBackend::LAYERS_CLIENT);
-
-    ShadowLayerForwarder* fwd = mLayerManager->AsShadowForwarder();
-    if (!fwd) {
-      return nullptr;
-    }
-    mTextureClient =
-      TextureClient::CreateForDrawing(fwd,
-                                      SurfaceFormat::A8,
-                                      mSize,
-                                      BackendSelector::Content,
-                                      TextureFlags::DISALLOW_BIGIMAGE,
-                                      TextureAllocationFlags::ALLOC_CLEAR_BUFFER);
-    if (!mTextureClient) {
-      return nullptr;
-    }
-
-    mTextureClientLocked = mTextureClient->Lock(OpenMode::OPEN_READ_WRITE);
-    if (!mTextureClientLocked) {
-      return nullptr;
-    }
-
-    mDrawTarget = mTextureClient->BorrowDrawTarget();
+  MOZ_ASSERT(mLayerManager);
+  if (mDrawTarget) {
+    return mDrawTarget;
+  }
+
+  if (mLayerManager->GetBackendType() == LayersBackend::LAYERS_BASIC) {
+    mDrawTarget = mLayerManager->CreateOptimalMaskDrawTarget(mSize);
     return mDrawTarget;
   }
 
-  already_AddRefed<Image> CreateImage()
-  {
-    if (mLayerManager->GetBackendType() == LayersBackend::LAYERS_BASIC &&
-        mDrawTarget) {
-      RefPtr<SourceSurface> surface = mDrawTarget->Snapshot();
-      RefPtr<SourceSurfaceImage> image = new SourceSurfaceImage(mSize, surface);
-      // Disallow BIGIMAGE (splitting into multiple textures) for mask
-      // layer images
-      image->SetTextureFlags(TextureFlags::DISALLOW_BIGIMAGE);
-      return image.forget();
-    }
-
-    if (mLayerManager->GetBackendType() == LayersBackend::LAYERS_CLIENT &&
-        mTextureClient &&
-        mDrawTarget) {
-      RefPtr<TextureWrapperImage> image =
-          new TextureWrapperImage(mTextureClient, gfx::IntRect(gfx::IntPoint(0, 0), mSize));
-      return image.forget();
-    }
+  MOZ_ASSERT(mLayerManager->GetBackendType() == LayersBackend::LAYERS_CLIENT);
+
+  ShadowLayerForwarder* fwd = mLayerManager->AsShadowForwarder();
+  if (!fwd) {
+    return nullptr;
+  }
+  mTextureClient =
+    TextureClient::CreateForDrawing(fwd,
+                                    SurfaceFormat::A8,
+                                    mSize,
+                                    BackendSelector::Content,
+                                    TextureFlags::DISALLOW_BIGIMAGE,
+                                    TextureAllocationFlags::ALLOC_CLEAR_BUFFER);
+  if (!mTextureClient) {
+    return nullptr;
+  }
+
+  mTextureClientLocked = mTextureClient->Lock(OpenMode::OPEN_READ_WRITE);
+  if (!mTextureClientLocked) {
     return nullptr;
   }
 
-private:
-  bool mTextureClientLocked;
-  gfx::IntSize mSize;
-  LayerManager* mLayerManager;
-  RefPtr<gfx::DrawTarget> mDrawTarget;
-  RefPtr<TextureClient> mTextureClient;
-};
+  mDrawTarget = mTextureClient->BorrowDrawTarget();
+  return mDrawTarget;
+}
+
+already_AddRefed<Image> MaskImageData::CreateImage()
+{
+  if (mLayerManager->GetBackendType() == LayersBackend::LAYERS_BASIC &&
+      mDrawTarget) {
+    RefPtr<SourceSurface> surface = mDrawTarget->Snapshot();
+    RefPtr<SourceSurfaceImage> image = new SourceSurfaceImage(mSize, surface);
+    // Disallow BIGIMAGE (splitting into multiple textures) for mask
+    // layer images
+    image->SetTextureFlags(TextureFlags::DISALLOW_BIGIMAGE);
+    return image.forget();
+  }
+
+  if (mLayerManager->GetBackendType() == LayersBackend::LAYERS_CLIENT &&
+      mTextureClient &&
+      mDrawTarget) {
+    RefPtr<TextureWrapperImage> image =
+        new TextureWrapperImage(mTextureClient, gfx::IntRect(gfx::IntPoint(0, 0), mSize));
+    return image.forget();
+  }
+  return nullptr;
+}
 
 /**
   * Helper functions for getting user data and casting it to the correct type.
   * aLayer is the layer where the user data is stored.
   */
 MaskLayerUserData* GetMaskLayerUserData(Layer* aLayer)
 {
   return static_cast<MaskLayerUserData*>(aLayer->GetUserData(&gMaskLayerUserData));

--- a/layout/base/FrameLayerBuilder.h
+++ b/layout/base/FrameLayerBuilder.h
@@ -28,16 +28,17 @@ class nsDisplayItemGeometry;
 namespace mozilla {
 class DisplayItemScrollClip;
 namespace layers {
 class ContainerLayer;
 class LayerManager;
 class BasicLayerManager;
 class PaintedLayer;
 class ImageLayer;
+class TextureClient;
 } // namespace layers
 
 class FrameLayerBuilder;
 class LayerManagerData;
 class PaintedLayerData;
 class ContainerState;
 
 class RefCountedRegion {
@@ -140,16 +141,38 @@ struct ContainerLayerParameters {
   {
     // If we're in a transformed subtree, but no ancestor transform is actively
     // changing, we'll use the residual translation when drawing into the
     // PaintedLayer to ensure that snapping exactly matches the ideal transform.
     return mInTransformedSubtree && !mInActiveTransformedSubtree;
   }
 };
 
+class MaskImageData
+{
+public:
+  typedef layers::Layer Layer;
+  typedef layers::Image Image;
+  typedef layers::ImageLayer ImageLayer;
+  typedef layers::LayerManager LayerManager;
+
+  MaskImageData(const gfx::IntSize& aSize, LayerManager* aLayerManager);
+  ~MaskImageData();
+
+  gfx::DrawTarget* CreateDrawTarget();
+  already_AddRefed<Image> CreateImage();
+
+private:
+  bool mTextureClientLocked;
+  gfx::IntSize mSize;
+  LayerManager* mLayerManager;
+  RefPtr<gfx::DrawTarget> mDrawTarget;
+  RefPtr<layers::TextureClient> mTextureClient;
+};
+
 /**
  * The FrameLayerBuilder is responsible for converting display lists 
  * into layer trees. Every LayerManager needs a unique FrameLayerBuilder
  * to build layers.
  * 
  * The most important API in this class is BuildContainerLayerFor. This
  * method takes a display list as input and constructs a ContainerLayer
  * with child layers that render the contents of the display list. It