Bug 874369 - Use normal memory instead of Shmem when only sharing between processes. r=Bas

gfx/layers/client/TextureClient.cpp

@@ -97,6 +97,7 @@ TextureClientShmem::SetDescriptor(const SurfaceDescriptor& aDescriptor)
 
   NS_ASSERTION(mDescriptor.type() == SurfaceDescriptor::TSurfaceDescriptorGralloc ||
                mDescriptor.type() == SurfaceDescriptor::TShmem ||
+               mDescriptor.type() == SurfaceDescriptor::TMemoryImage ||
                mDescriptor.type() == SurfaceDescriptor::TRGBImage,
                "Invalid surface descriptor");
 }

gfx/layers/ipc/ISurfaceAllocator.cpp

@@ -13,6 +13,7 @@
 #include "mozilla/layers/LayersSurfaces.h"
 #include "mozilla/layers/SharedPlanarYCbCrImage.h"
 #include "mozilla/layers/SharedRGBImage.h"
+#include "nsXULAppAPI.h"
 
 #ifdef DEBUG
 #include "prenv.h"
@@ -85,6 +86,17 @@ ISurfaceAllocator::AllocSurfaceDescriptorWithCaps(const gfxIntSize& aSize,
     return true;
   }
 
+  if (XRE_GetProcessType() == GeckoProcessType_Default) {
+    gfxImageFormat format = aContent == gfxASurface::CONTENT_COLOR_ALPHA ?
+                            gfxASurface::ImageFormatARGB32 :
+                            gfxASurface::ImageFormatRGB24;
+    int32_t stride = gfxASurface::FormatStrideForWidth(format, aSize.width);
+    uint8_t *data = new uint8_t[stride * aSize.height];
+
+    *aBuffer = MemoryImage((uintptr_t)data, aSize, stride, format);
+    return true;
+  }
+
   nsRefPtr<gfxSharedImageSurface> buffer;
   if (!AllocSharedImageSurface(aSize, aContent,
                                getter_AddRefs(buffer))) {
@@ -122,6 +134,9 @@ ISurfaceAllocator::DestroySharedSurface(SurfaceDescriptor* aSurface)
       break;
     case SurfaceDescriptor::TSurfaceDescriptorD3D10:
       break;
+    case SurfaceDescriptor::TMemoryImage:
+      delete [] (unsigned char *)aSurface->get_MemoryImage().data();
+      break;
     case SurfaceDescriptor::Tnull_t:
     case SurfaceDescriptor::T__None:
       break;

gfx/layers/ipc/LayersSurfaces.ipdlh

@@ -83,6 +83,13 @@ struct RGBImage {
   uint64_t owner;
 };
 
+struct MemoryImage {
+  uintptr_t data;
+  gfxIntSize size;
+  uint32_t stride;
+  uint32_t format;
+};
+
 union SurfaceDescriptor {
   Shmem;
   SurfaceDescriptorD3D10;
@@ -92,6 +99,7 @@ union SurfaceDescriptor {
   RGBImage;
   SharedTextureDescriptor;
   SurfaceStreamDescriptor;
+  MemoryImage;
   null_t;
 };
 

gfx/layers/ipc/ShadowLayerUtilsMac.cpp

@@ -32,10 +32,22 @@ ISurfaceAllocator::PlatformAllocSurfaceDescriptor(const gfxIntSize& aSize,
 ShadowLayerForwarder::PlatformOpenDescriptor(OpenMode aMode,
                                              const SurfaceDescriptor& aSurface)
 {
-  if (SurfaceDescriptor::TShmem != aSurface.type()) {
-    return nullptr;
+  if (aSurface.type() == SurfaceDescriptor::TShmem) {
+    return gfxSharedQuartzSurface::Open(aSurface.get_Shmem());
+  } else if (aSurface.type() == SurfaceDescriptor::TMemoryImage) {
+    const MemoryImage& image = aSurface.get_MemoryImage();
+    gfxASurface::gfxImageFormat format
+      = static_cast<gfxASurface::gfxImageFormat>(image.format());
+
+    nsRefPtr<gfxASurface> surf =
+      new gfxQuartzSurface((unsigned char*)image.data(),
+                           image.size(),
+                           image.stride(),
+                           format);
+    return surf.forget();
+
   }
-  return gfxSharedQuartzSurface::Open(aSurface.get_Shmem());
+  return nullptr;
 }
 
 /*static*/ bool

gfx/layers/ipc/ShadowLayers.cpp

@@ -530,6 +530,16 @@ ShadowLayerForwarder::OpenDescriptor(OpenMode aMode,
                                rgbFormat);
     return surf.forget();
   }
+  case SurfaceDescriptor::TMemoryImage: {
+    const MemoryImage& image = aSurface.get_MemoryImage();
+    gfxASurface::gfxImageFormat format
+      = static_cast<gfxASurface::gfxImageFormat>(image.format());
+    surf = new gfxImageSurface((unsigned char *)image.data(),
+                               image.size(),
+                               image.stride(),
+                               format);
+    return surf.forget();
+  }
   default:
     NS_ERROR("unexpected SurfaceDescriptor type!");
     return nullptr;

gfx/thebes/gfxQuartzSurface.cpp

@@ -125,6 +125,29 @@ gfxQuartzSurface::gfxQuartzSurface(unsigned char *data,
     }
 }
 
+gfxQuartzSurface::gfxQuartzSurface(unsigned char *data,
+                                   const gfxIntSize& aSize,
+                                   long stride,
+                                   gfxImageFormat format,
+                                   bool aForPrinting)
+    : mCGContext(nullptr), mSize(aSize.width, aSize.height), mForPrinting(aForPrinting)
+{
+    if (!CheckSurfaceSize(aSize))
+        MakeInvalid();
+
+    cairo_surface_t *surf = cairo_quartz_surface_create_for_data
+        (data, (cairo_format_t) format, aSize.width, aSize.height, stride);
+
+    mCGContext = cairo_quartz_surface_get_cg_context (surf);
+
+    CGContextRetain(mCGContext);
+
+    Init(surf);
+    if (mSurfaceValid) {
+      RecordMemoryUsed(mSize.height * stride + sizeof(gfxQuartzSurface));
+    }
+}
+
 already_AddRefed<gfxASurface>
 gfxQuartzSurface::CreateSimilarSurface(gfxContentType aType,
                                        const gfxIntSize& aSize)

gfx/thebes/gfxQuartzSurface.h

@@ -20,6 +20,7 @@ public:
     gfxQuartzSurface(CGContextRef context, const gfxIntSize& size, bool aForPrinting = false);
     gfxQuartzSurface(cairo_surface_t *csurf, bool aForPrinting = false);
     gfxQuartzSurface(unsigned char *data, const gfxSize& size, long stride, gfxImageFormat format, bool aForPrinting = false);
+    gfxQuartzSurface(unsigned char *data, const gfxIntSize& size, long stride, gfxImageFormat format, bool aForPrinting = false);
 
     virtual ~gfxQuartzSurface();