Mercurial > hg > CommitWatcher

changeset 12:a0ff003319ec

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
foo
author Jeff Hammel <jhammel@mozilla.com>
date Sat, 28 Sep 2013 06:40:25 -0700
parents 546695da018c
children fc91a93fcaee
files commitwatcher/agent.py tests/4e1a3919e741.diff tests/unit.py
diffstat 3 files changed, 1010 insertions(+), 4 deletions(-) [+]
line wrap: on
line diff
--- a/commitwatcher/agent.py	Sat Sep 28 05:15:59 2013 -0700
+++ b/commitwatcher/agent.py	Sat Sep 28 06:40:25 2013 -0700
@@ -3,8 +3,8 @@
 """
 
 import feedparser
-import pypatch
 from abc import abstractmethod
+from pypatch import patch
 from .commit import Commit
 from .store import MemoryStore
 
@@ -51,8 +51,8 @@
 
     @staticmethod
     def lsdiff(diff):
-        
-        
+        import pdb; pdb.set_trace()
+
     def diff_url(self, link):
         """
         returns diff_url from revision link:
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/tests/4e1a3919e741.diff	Sat Sep 28 06:40:25 2013 -0700
@@ -0,0 +1,1005 @@
+
+# HG changeset patch
+# User Nicholas Cameron <ncameron@mozilla.com>
+# Date 1380242239 -43200
+# Node ID 4e1a3919e741eb8e3a4f520535671df9711b5b9b
+# Parent  a11f8859f7d84ed1a7ab3596c9242074a8a4dc35
+Bug 882113. Azurification of compositor classes. r=mattwoodrow
+
+diff --git a/gfx/gl/GLContext.cpp b/gfx/gl/GLContext.cpp
+--- a/gfx/gl/GLContext.cpp
++++ b/gfx/gl/GLContext.cpp
+@@ -2080,16 +2080,33 @@ GetActualReadFormats(GLContext* gl, GLen
+ void
+ GLContext::ReadScreenIntoImageSurface(gfxImageSurface* dest)
+ {
+     ScopedBindFramebuffer autoFB(this, 0);
+ 
+     ReadPixelsIntoImageSurface(dest);
+ }
+ 
++TemporaryRef<SourceSurface>
++GLContext::ReadPixelsToSourceSurface(const gfx::IntSize &aSize)
++{
++    // XXX we should do this properly one day without using the gfxImageSurface
++    RefPtr<DataSourceSurface> dataSourceSurface =
++        Factory::CreateDataSourceSurface(aSize, gfx::FORMAT_B8G8R8A8);
++    nsRefPtr<gfxImageSurface> surf =
++        new gfxImageSurface(dataSourceSurface->GetData(),
++                            gfxIntSize(aSize.width, aSize.height),
++                            dataSourceSurface->Stride(),
++                            gfxImageFormatARGB32);
++    ReadPixelsIntoImageSurface(surf);
++    dataSourceSurface->MarkDirty();
++
++    return dataSourceSurface;
++}
++
+ void
+ GLContext::ReadPixelsIntoImageSurface(gfxImageSurface* dest)
+ {
+     MakeCurrent();
+     MOZ_ASSERT(dest->GetSize() != gfxIntSize(0, 0));
+ 
+     /* gfxImageFormatARGB32:
+      * RGBA+UByte: be[RGBA], le[ABGR]
+diff --git a/gfx/gl/GLContext.h b/gfx/gl/GLContext.h
+--- a/gfx/gl/GLContext.h
++++ b/gfx/gl/GLContext.h
+@@ -47,16 +47,17 @@ class nsIThread;
+ 
+ namespace android {
+     class GraphicBuffer;
+ }
+ 
+ namespace mozilla {
+     namespace gfx {
+         class SharedSurface;
++        class SourceSurface;
+         class DataSourceSurface;
+         struct SurfaceCaps;
+     }
+ 
+     namespace gl {
+         class GLContext;
+         class GLLibraryEGL;
+         class GLScreenBuffer;
+@@ -2696,16 +2697,18 @@ public:
+      * ReadScreenIntoImageSurface call dest->Flush/MarkDirty.
+      */
+     void ReadPixelsIntoImageSurface(gfxImageSurface* dest);
+ 
+     // Similar to ReadPixelsIntoImageSurface, but pulls from the screen
+     // instead of the currently bound framebuffer.
+     void ReadScreenIntoImageSurface(gfxImageSurface* dest);
+ 
++    TemporaryRef<gfx::SourceSurface> ReadPixelsToSourceSurface(const gfx::IntSize &aSize);
++
+     /**
+      * Copy a rectangle from one TextureImage into another.  The
+      * source and destination are given in integer coordinates, and
+      * will be converted to texture coordinates.
+      *
+      * For the source texture, the wrap modes DO apply -- it's valid
+      * to use REPEAT or PAD and expect appropriate behaviour if the source
+      * rectangle extends beyond its bounds.
+diff --git a/gfx/layers/Compositor.h b/gfx/layers/Compositor.h
+--- a/gfx/layers/Compositor.h
++++ b/gfx/layers/Compositor.h
+@@ -2,17 +2,16 @@
+ * 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_GFX_COMPOSITOR_H
+ #define MOZILLA_GFX_COMPOSITOR_H
+ 
+ #include "Units.h"                      // for ScreenPoint
+-#include "gfxPoint.h"                   // for gfxIntSize
+ #include "mozilla/Assertions.h"         // for MOZ_ASSERT, etc
+ #include "mozilla/RefPtr.h"             // for TemporaryRef, RefCounted
+ #include "mozilla/gfx/Point.h"          // for IntSize, Point
+ #include "mozilla/gfx/Rect.h"           // for Rect, IntRect
+ #include "mozilla/gfx/Types.h"          // for Float
+ #include "mozilla/layers/CompositorTypes.h"  // for DiagnosticTypes, etc
+ #include "mozilla/layers/LayersTypes.h"  // for LayersBackend
+ #include "nsTraceRefcnt.h"              // for MOZ_COUNT_CTOR, etc
+@@ -97,24 +96,24 @@
+  * under gfx/layers/. To add a new backend, implement at least the following
+  * interfaces:
+  * - Compositor (ex. CompositorOGL)
+  * - TextureHost (ex. SharedTextureHostOGL)
+  * Depending on the type of data that needs to be serialized, you may need to
+  * add specific TextureClient implementations.
+  */
+ 
+-class gfxContext;
+ class nsIWidget;
+ struct gfxMatrix;
+ struct nsIntSize;
+ 
+ namespace mozilla {
+ namespace gfx {
+ class Matrix4x4;
++class DrawTarget;
+ }
+ 
+ namespace layers {
+ 
+ struct Effect;
+ struct EffectChain;
+ class Image;
+ class ISurfaceAllocator;
+@@ -205,27 +204,27 @@ public:
+    * across process or thread boundaries that are compatible with this
+    * compositor.
+    */
+   virtual TextureFactoryIdentifier GetTextureFactoryIdentifier() = 0;
+ 
+   /**
+    * Properties of the compositor.
+    */
+-  virtual bool CanUseCanvasLayerForSize(const gfxIntSize& aSize) = 0;
++  virtual bool CanUseCanvasLayerForSize(const gfx::IntSize& aSize) = 0;
+   virtual int32_t GetMaxTextureSize() const = 0;
+ 
+   /**
+    * Set the target for rendering. Results will have been written to aTarget by
+    * the time that EndFrame returns.
+    *
+    * If this method is not used, or we pass in nullptr, we target the compositor's
+    * usual swap chain and render to the screen.
+    */
+-  virtual void SetTargetContext(gfxContext* aTarget) = 0;
++  virtual void SetTargetContext(gfx::DrawTarget* aTarget) = 0;
+ 
+   typedef uint32_t MakeCurrentFlags;
+   static const MakeCurrentFlags ForceMakeCurrent = 0x1;
+   /**
+    * Make this compositor's rendering context the current context for the
+    * underlying graphics API. This may be a global operation, depending on the
+    * API. Our context will remain the current one until someone else changes it.
+    *
+diff --git a/gfx/layers/Layers.cpp b/gfx/layers/Layers.cpp
+--- a/gfx/layers/Layers.cpp
++++ b/gfx/layers/Layers.cpp
+@@ -1166,19 +1166,20 @@ void WriteSnapshotToDumpFile(Layer* aLay
+   WriteSnapshotToDumpFile_internal(aLayer, aSurf);
+ }
+ 
+ void WriteSnapshotToDumpFile(LayerManager* aManager, gfxASurface* aSurf)
+ {
+   WriteSnapshotToDumpFile_internal(aManager, aSurf);
+ }
+ 
+-void WriteSnapshotToDumpFile(Compositor* aCompositor, gfxASurface* aSurf)
++void WriteSnapshotToDumpFile(Compositor* aCompositor, DrawTarget* aTarget)
+ {
+-  WriteSnapshotToDumpFile_internal(aCompositor, aSurf);
++  nsRefPtr<gfxASurface> surf = gfxPlatform::GetPlatform()->GetThebesSurfaceForDrawTarget(aTarget);
++  WriteSnapshotToDumpFile_internal(aCompositor, surf);
+ }
+ #endif
+ 
+ void
+ Layer::Dump(FILE* aFile, const char* aPrefix, bool aDumpHtml)
+ {
+   if (aDumpHtml) {
+     fprintf(aFile, "<li><a id=\"%p\" ", this);
+diff --git a/gfx/layers/Layers.h b/gfx/layers/Layers.h
+--- a/gfx/layers/Layers.h
++++ b/gfx/layers/Layers.h
+@@ -1955,15 +1955,15 @@ protected:
+   Layer* mTempReferent;
+   // 0 is a special value that means "no ID".
+   uint64_t mId;
+ };
+ 
+ #ifdef MOZ_DUMP_PAINTING
+ void WriteSnapshotToDumpFile(Layer* aLayer, gfxASurface* aSurf);
+ void WriteSnapshotToDumpFile(LayerManager* aManager, gfxASurface* aSurf);
+-void WriteSnapshotToDumpFile(Compositor* aCompositor, gfxASurface* aSurf);
++void WriteSnapshotToDumpFile(Compositor* aCompositor, gfx::DrawTarget* aTarget);
+ #endif
+ 
+ }
+ }
+ 
+ #endif /* GFX_LAYERS_H */
+diff --git a/gfx/layers/basic/BasicCompositor.cpp b/gfx/layers/basic/BasicCompositor.cpp
+--- a/gfx/layers/basic/BasicCompositor.cpp
++++ b/gfx/layers/basic/BasicCompositor.cpp
+@@ -464,30 +464,27 @@ BasicCompositor::BeginFrame(const gfx::R
+   }
+ }
+ 
+ void
+ BasicCompositor::EndFrame()
+ {
+   mRenderTarget->mDrawTarget->PopClip();
+ 
++  RefPtr<SourceSurface> source = mRenderTarget->mDrawTarget->Snapshot();
+   if (mCopyTarget) {
+-    nsRefPtr<gfxASurface> thebes = gfxPlatform::GetPlatform()->GetThebesSurfaceForDrawTarget(mRenderTarget->mDrawTarget);
+-    gfxContextAutoSaveRestore restore(mCopyTarget);
+-    mCopyTarget->SetOperator(gfxContext::OPERATOR_SOURCE);
+-    mCopyTarget->SetSource(thebes);
+-    mCopyTarget->Paint();
+-    mCopyTarget = nullptr;
++    mCopyTarget->CopySurface(source,
++                             IntRect(0, 0, mWidgetSize.width, mWidgetSize.height),
++                             IntPoint(0, 0));
+   } else {
+     // Most platforms require us to buffer drawing to the widget surface.
+     // That's why we don't draw to mDrawTarget directly.
+-    RefPtr<SourceSurface> source = mRenderTarget->mDrawTarget->Snapshot();
+     mDrawTarget->CopySurface(source,
+-	                     IntRect(0, 0, mWidgetSize.width, mWidgetSize.height),
+-			     IntPoint(0, 0));
++	                           IntRect(0, 0, mWidgetSize.width, mWidgetSize.height),
++			                       IntPoint(0, 0));
+     mWidget->EndRemoteDrawing();
+   }
+   mDrawTarget = nullptr;
+   mRenderTarget = nullptr;
+ }
+ 
+ void
+ BasicCompositor::AbortFrame()
+diff --git a/gfx/layers/basic/BasicCompositor.h b/gfx/layers/basic/BasicCompositor.h
+--- a/gfx/layers/basic/BasicCompositor.h
++++ b/gfx/layers/basic/BasicCompositor.h
+@@ -89,20 +89,20 @@ public:
+   virtual void EndFrame() MOZ_OVERRIDE;
+   virtual void EndFrameForExternalComposition(const gfxMatrix& aTransform) MOZ_OVERRIDE
+   {
+     NS_RUNTIMEABORT("We shouldn't ever hit this");
+   }
+   virtual void AbortFrame() MOZ_OVERRIDE;
+ 
+   virtual bool SupportsPartialTextureUpdate() { return true; }
+-  virtual bool CanUseCanvasLayerForSize(const gfxIntSize &aSize) MOZ_OVERRIDE { return true; }
++  virtual bool CanUseCanvasLayerForSize(const gfx::IntSize &aSize) MOZ_OVERRIDE { return true; }
+   virtual int32_t GetMaxTextureSize() const MOZ_OVERRIDE { return INT32_MAX; }
+   virtual void SetDestinationSurfaceSize(const gfx::IntSize& aSize) MOZ_OVERRIDE { }
+-  virtual void SetTargetContext(gfxContext* aTarget) MOZ_OVERRIDE
++  virtual void SetTargetContext(gfx::DrawTarget* aTarget) MOZ_OVERRIDE
+   {
+     mCopyTarget = aTarget;
+   }
+   
+   virtual void SetScreenRenderOffset(const ScreenPoint& aOffset) MOZ_OVERRIDE {
+   }
+ 
+   virtual void MakeCurrent(MakeCurrentFlags aFlags = 0) { }
+@@ -128,15 +128,15 @@ private:
+   nsIntSize mWidgetSize;
+ 
+   // The final destination surface
+   RefPtr<gfx::DrawTarget> mDrawTarget;
+   // The current render target for drawing
+   RefPtr<BasicCompositingRenderTarget> mRenderTarget;
+   // An optional destination target to copy the results
+   // to after drawing is completed.
+-  nsRefPtr<gfxContext> mCopyTarget;
++  RefPtr<gfx::DrawTarget> mCopyTarget;
+ };
+ 
+ } // namespace layers
+ } // namespace mozilla
+ 
+ #endif /* MOZILLA_GFX_BASICCOMPOSITOR_H */
+diff --git a/gfx/layers/composite/LayerManagerComposite.cpp b/gfx/layers/composite/LayerManagerComposite.cpp
+--- a/gfx/layers/composite/LayerManagerComposite.cpp
++++ b/gfx/layers/composite/LayerManagerComposite.cpp
+@@ -143,17 +143,17 @@ LayerManagerComposite::UpdateRenderBound
+ 
+ void
+ LayerManagerComposite::BeginTransaction()
+ {
+   mInTransaction = true;
+ }
+ 
+ void
+-LayerManagerComposite::BeginTransactionWithTarget(gfxContext *aTarget)
++LayerManagerComposite::BeginTransactionWithDrawTarget(DrawTarget* aTarget)
+ {
+   mInTransaction = true;
+ 
+ #ifdef MOZ_LAYERS_HAVE_LOG
+   MOZ_LAYERS_LOG(("[----- BeginTransaction"));
+   Log();
+ #endif
+ 
+@@ -757,17 +757,18 @@ void
+ LayerManagerComposite::NotifyShadowTreeTransaction()
+ {
+   mCompositor->NotifyLayersTransaction();
+ }
+ 
+ bool
+ LayerManagerComposite::CanUseCanvasLayerForSize(const gfxIntSize &aSize)
+ {
+-  return mCompositor->CanUseCanvasLayerForSize(aSize);
++  return mCompositor->CanUseCanvasLayerForSize(gfx::IntSize(aSize.width,
++                                                            aSize.height));
+ }
+ 
+ TextureFactoryIdentifier
+ LayerManagerComposite::GetTextureFactoryIdentifier()
+ {
+   return mCompositor->GetTextureFactoryIdentifier();
+ }
+ 
+diff --git a/gfx/layers/composite/LayerManagerComposite.h b/gfx/layers/composite/LayerManagerComposite.h
+--- a/gfx/layers/composite/LayerManagerComposite.h
++++ b/gfx/layers/composite/LayerManagerComposite.h
+@@ -97,18 +97,22 @@ public:
+    */
+   virtual LayerManagerComposite* AsLayerManagerComposite() MOZ_OVERRIDE
+   {
+     return this;
+   }
+ 
+   void UpdateRenderBounds(const nsIntRect& aRect);
+ 
+-  void BeginTransaction() MOZ_OVERRIDE;
+-  void BeginTransactionWithTarget(gfxContext* aTarget) MOZ_OVERRIDE;
++  virtual void BeginTransaction() MOZ_OVERRIDE;
++  virtual void BeginTransactionWithTarget(gfxContext* aTarget) MOZ_OVERRIDE
++  {
++    MOZ_CRASH("Use BeginTransactionWithDrawTarget");
++  }
++  void BeginTransactionWithDrawTarget(gfx::DrawTarget* aTarget);
+ 
+   void NotifyShadowTreeTransaction();
+ 
+   virtual bool EndEmptyTransaction(EndTransactionFlags aFlags = END_DEFAULT) MOZ_OVERRIDE;
+   virtual void EndTransaction(DrawThebesLayerCallback aCallback,
+                               void* aCallbackData,
+                               EndTransactionFlags aFlags = END_DEFAULT) MOZ_OVERRIDE;
+ 
+diff --git a/gfx/layers/d3d11/CompositorD3D11.cpp b/gfx/layers/d3d11/CompositorD3D11.cpp
+--- a/gfx/layers/d3d11/CompositorD3D11.cpp
++++ b/gfx/layers/d3d11/CompositorD3D11.cpp
+@@ -344,17 +344,17 @@ CompositorD3D11::GetTextureFactoryIdenti
+   TextureFactoryIdentifier ident;
+   ident.mMaxTextureSize = GetMaxTextureSize();
+   ident.mParentProcessId = XRE_GetProcessType();
+   ident.mParentBackend = LAYERS_D3D11;
+   return ident;
+ }
+ 
+ bool
+-CompositorD3D11::CanUseCanvasLayerForSize(const gfxIntSize& aSize)
++CompositorD3D11::CanUseCanvasLayerForSize(const gfx::IntSize& aSize)
+ {
+   int32_t maxTextureSize = GetMaxTextureSize();
+ 
+   if (aSize.width > maxTextureSize || aSize.height > maxTextureSize) {
+     return false;
+   }
+ 
+   return true;
+@@ -903,23 +903,23 @@ CompositorD3D11::PaintToTarget()
+   nsRefPtr<ID3D11Texture2D> readTexture;
+ 
+   HRESULT hr = mDevice->CreateTexture2D(&softDesc, nullptr, getter_AddRefs(readTexture));
+   mContext->CopyResource(readTexture, backBuf);
+ 
+   D3D11_MAPPED_SUBRESOURCE map;
+   mContext->Map(readTexture, 0, D3D11_MAP_READ, 0, &map);
+ 
+-  nsRefPtr<gfxImageSurface> tmpSurface =
+-    new gfxImageSurface((unsigned char*)map.pData,
+-                        gfxIntSize(bbDesc.Width, bbDesc.Height),
+-                        map.RowPitch,
+-                        gfxImageFormatARGB32);
+-
+-  mTarget->SetSource(tmpSurface);
+-  mTarget->SetOperator(gfxContext::OPERATOR_SOURCE);
+-  mTarget->Paint();
+-
++  destSurf->LockRect(&rect, NULL, D3DLOCK_READONLY);
++  RefPtr<DataSourceSurface> sourceSurface =
++    Factory::CreateWrappingDataSourceSurface((uint8_t*)map.pData,
++                                             map.RowPitch,
++                                             IntSize(bbDesc.Width, bbDesc.Height),
++                                             FORMAT_B8G8R8A8);
++  mTarget->CopySurface(sourceSurface,
++                       IntRect(0, 0, bbDesc.Width, bbDesc.Height),
++                       IntPoint());
++  mTarget->Flush();
+   mContext->Unmap(readTexture, 0);
+ }
+ 
+ }
+ }
+diff --git a/gfx/layers/d3d11/CompositorD3D11.h b/gfx/layers/d3d11/CompositorD3D11.h
+--- a/gfx/layers/d3d11/CompositorD3D11.h
++++ b/gfx/layers/d3d11/CompositorD3D11.h
+@@ -1,16 +1,17 @@
+ /* -*- Mode: C++; tab-width: 20; 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/. */
+ 
+ #ifndef MOZILLA_GFX_COMPOSITORD3D11_H
+ #define MOZILLA_GFX_COMPOSITORD3D11_H
+ 
++#include "mozilla/gfx/2D.h"
+ #include "mozilla/layers/Compositor.h"
+ #include "TextureD3D11.h"
+ #include <d3d11.h>
+ 
+ class nsWidget;
+ 
+ namespace mozilla {
+ namespace layers {
+@@ -45,20 +46,20 @@ public:
+   virtual void Destroy() MOZ_OVERRIDE {}
+ 
+   virtual TextureFactoryIdentifier
+     GetTextureFactoryIdentifier() MOZ_OVERRIDE;
+ 
+   virtual TemporaryRef<DataTextureSource>
+     CreateDataTextureSource(TextureFlags aFlags = 0) MOZ_OVERRIDE { return nullptr; }
+ 
+-  virtual bool CanUseCanvasLayerForSize(const gfxIntSize& aSize) MOZ_OVERRIDE;
++  virtual bool CanUseCanvasLayerForSize(const gfx::IntSize& aSize) MOZ_OVERRIDE;
+   virtual int32_t GetMaxTextureSize() const MOZ_FINAL;
+ 
+-  virtual void SetTargetContext(gfxContext* aTarget)  MOZ_OVERRIDE
++  virtual void SetTargetContext(gfx::DrawTarget* aTarget)  MOZ_OVERRIDE
+   {
+     mTarget = aTarget;
+   }
+ 
+   virtual void MakeCurrent(MakeCurrentFlags aFlags = 0)  MOZ_OVERRIDE {}
+ 
+   virtual TemporaryRef<CompositingRenderTarget>
+     CreateRenderTarget(const gfx::IntRect &aRect,
+@@ -162,17 +163,17 @@ private:
+   RefPtr<ID3D11DeviceContext> mContext;
+   RefPtr<ID3D11Device> mDevice;
+   RefPtr<IDXGISwapChain> mSwapChain;
+   RefPtr<CompositingRenderTargetD3D11> mDefaultRT;
+   RefPtr<CompositingRenderTargetD3D11> mCurrentRT;
+ 
+   DeviceAttachmentsD3D11* mAttachments;
+ 
+-  nsRefPtr<gfxContext> mTarget;
++  RefPtr<gfx::DrawTarget> mTarget;
+ 
+   nsIWidget* mWidget;
+ 
+   nsIntSize mSize;
+ 
+   HWND mHwnd;
+ 
+   D3D_FEATURE_LEVEL mFeatureLevel;
+diff --git a/gfx/layers/d3d9/CompositorD3D9.cpp b/gfx/layers/d3d9/CompositorD3D9.cpp
+--- a/gfx/layers/d3d9/CompositorD3D9.cpp
++++ b/gfx/layers/d3d9/CompositorD3D9.cpp
+@@ -60,17 +60,17 @@ CompositorD3D9::GetTextureFactoryIdentif
+   TextureFactoryIdentifier ident;
+   ident.mMaxTextureSize = GetMaxTextureSize();
+   ident.mParentBackend = LAYERS_D3D9;
+   ident.mParentProcessId = XRE_GetProcessType();
+   return ident;
+ }
+ 
+ bool
+-CompositorD3D9::CanUseCanvasLayerForSize(const gfxIntSize &aSize)
++CompositorD3D9::CanUseCanvasLayerForSize(const IntSize &aSize)
+ {
+   int32_t maxTextureSize = GetMaxTextureSize();
+ 
+   if (aSize.width > maxTextureSize || aSize.height > maxTextureSize) {
+     return false;
+   }
+ 
+   return true;
+@@ -560,24 +560,25 @@ CompositorD3D9::PaintToTarget()
+   device()->CreateOffscreenPlainSurface(desc.Width, desc.Height,
+                                         D3DFMT_A8R8G8B8, D3DPOOL_SYSTEMMEM,
+                                         getter_AddRefs(destSurf), NULL);
+ 
+   device()->GetRenderTargetData(backBuff, destSurf);
+ 
+   D3DLOCKED_RECT rect;
+   destSurf->LockRect(&rect, NULL, D3DLOCK_READONLY);
+-  mTarget->SetOperator(gfxContext::OPERATOR_SOURCE);
+-  nsRefPtr<gfxImageSurface> imageSurface =
+-    new gfxImageSurface((unsigned char*)rect.pBits,
+-                        gfxIntSize(desc.Width, desc.Height),
+-                        rect.Pitch,
+-                        gfxImageFormatARGB32);
+-  mTarget->SetSource(imageSurface);
+-  mTarget->Paint();
++  RefPtr<DataSourceSurface> sourceSurface =
++    Factory::CreateWrappingDataSourceSurface((uint8_t*)rect.pBits,
++                                             rect.Pitch,
++                                             IntSize(desc.Width, desc.Height),
++                                             FORMAT_B8G8R8A8);
++  mTarget->CopySurface(sourceSurface,
++                       IntRect(0, 0, desc.Width, desc.Height),
++                       IntPoint());
++  mTarget->Flush();
+   destSurf->UnlockRect();
+ }
+ 
+ void
+ CompositorD3D9::ReportFailure(const nsACString &aMsg, HRESULT aCode)
+ {
+   // We could choose to abort here when hr == E_OUTOFMEMORY.
+   nsCString msg;
+diff --git a/gfx/layers/d3d9/CompositorD3D9.h b/gfx/layers/d3d9/CompositorD3D9.h
+--- a/gfx/layers/d3d9/CompositorD3D9.h
++++ b/gfx/layers/d3d9/CompositorD3D9.h
+@@ -1,16 +1,17 @@
+ /* -*- Mode: C++; tab-width: 20; 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/. */
+ 
+ #ifndef MOZILLA_GFX_COMPOSITORD3D9_H
+ #define MOZILLA_GFX_COMPOSITORD3D9_H
+ 
++#include "mozilla/gfx/2D.h"
+ #include "mozilla/layers/Compositor.h"
+ #include "mozilla/layers/TextureD3D9.h"
+ #include "DeviceManagerD3D9.h"
+ 
+ class nsWidget;
+ 
+ namespace mozilla {
+ namespace layers {
+@@ -22,20 +23,20 @@ public:
+   ~CompositorD3D9();
+ 
+   virtual bool Initialize() MOZ_OVERRIDE;
+   virtual void Destroy() MOZ_OVERRIDE {}
+ 
+   virtual TextureFactoryIdentifier
+     GetTextureFactoryIdentifier() MOZ_OVERRIDE;
+ 
+-  virtual bool CanUseCanvasLayerForSize(const gfxIntSize &aSize) MOZ_OVERRIDE;
++  virtual bool CanUseCanvasLayerForSize(const gfx::IntSize &aSize) MOZ_OVERRIDE;
+   virtual int32_t GetMaxTextureSize() const MOZ_FINAL;
+ 
+-  virtual void SetTargetContext(gfxContext *aTarget) MOZ_OVERRIDE
++  virtual void SetTargetContext(gfx::DrawTarget *aTarget) MOZ_OVERRIDE
+   {
+     mTarget = aTarget;
+   }
+ 
+   virtual void MakeCurrent(MakeCurrentFlags aFlags = 0) MOZ_OVERRIDE {}
+ 
+   virtual TemporaryRef<CompositingRenderTarget>
+     CreateRenderTarget(const gfx::IntRect &aRect,
+@@ -123,17 +124,17 @@ private:
+   nsRefPtr<SwapChainD3D9> mSwapChain;
+ 
+   /* Widget associated with this layer manager */
+   nsIWidget *mWidget;
+ 
+   /*
+    * Context target, NULL when drawing directly to our swap chain.
+    */
+-  nsRefPtr<gfxContext> mTarget;
++  RefPtr<gfx::DrawTarget> mTarget;
+ 
+   RefPtr<CompositingRenderTargetD3D9> mDefaultRT;
+   RefPtr<CompositingRenderTargetD3D9> mCurrentRT;
+ 
+   nsIntSize mSize;
+ };
+ 
+ }
+diff --git a/gfx/layers/ipc/CompositorParent.cpp b/gfx/layers/ipc/CompositorParent.cpp
+--- a/gfx/layers/ipc/CompositorParent.cpp
++++ b/gfx/layers/ipc/CompositorParent.cpp
+@@ -18,16 +18,17 @@
+ #include "base/task.h"                  // for CancelableTask, etc
+ #include "base/thread.h"                // for Thread
+ #include "base/tracked.h"               // for FROM_HERE
+ #include "gfxContext.h"                 // for gfxContext
+ #include "gfxPlatform.h"                // for gfxPlatform
+ #include "ipc/ShadowLayersManager.h"    // for ShadowLayersManager
+ #include "mozilla/AutoRestore.h"        // for AutoRestore
+ #include "mozilla/DebugOnly.h"          // for DebugOnly
++#include "mozilla/gfx/2D.h"          // for DrawTarget
+ #include "mozilla/gfx/Point.h"          // for IntSize
+ #include "mozilla/ipc/Transport.h"      // for Transport
+ #include "mozilla/layers/APZCTreeManager.h"  // for APZCTreeManager
+ #include "mozilla/layers/AsyncCompositionManager.h"
+ #include "mozilla/layers/BasicCompositor.h"  // for BasicCompositor
+ #include "mozilla/layers/Compositor.h"  // for Compositor
+ #include "mozilla/layers/CompositorOGL.h"  // for CompositorOGL
+ #include "mozilla/layers/CompositorTypes.h"
+@@ -47,16 +48,17 @@
+ #include "mozilla/layers/CompositorD3D11.h"
+ #include "mozilla/layers/CompositorD3D9.h"
+ #endif
+ #include "GeckoProfiler.h"
+ 
+ using namespace base;
+ using namespace mozilla;
+ using namespace mozilla::ipc;
++using namespace mozilla::gfx;
+ using namespace std;
+ 
+ namespace mozilla {
+ namespace layers {
+ 
+ CompositorParent::LayerTreeState::LayerTreeState()
+   : mParent(nullptr)
+ {
+@@ -290,17 +292,23 @@ CompositorParent::RecvResume()
+   return true;
+ }
+ 
+ bool
+ CompositorParent::RecvMakeSnapshot(const SurfaceDescriptor& aInSnapshot,
+                                    SurfaceDescriptor* aOutSnapshot)
+ {
+   AutoOpenSurface opener(OPEN_READ_WRITE, aInSnapshot);
+-  nsRefPtr<gfxContext> target = new gfxContext(opener.Get());
++  gfxIntSize size = opener.Size();
++  // XXX CreateDrawTargetForSurface will always give us a Cairo surface, we can
++  // do better if AutoOpenSurface uses Moz2D directly.
++  RefPtr<DrawTarget> target =
++    gfxPlatform::GetPlatform()->CreateDrawTargetForSurface(opener.Get(),
++                                                           IntSize(size.width,
++                                                                   size.height));
+   ComposeToTarget(target);
+   *aOutSnapshot = aInSnapshot;
+   return true;
+ }
+ 
+ bool
+ CompositorParent::RecvFlushRendering()
+ {
+@@ -536,26 +544,26 @@ CompositorParent::Composite()
+   if (mExpectedComposeTime + TimeDuration::FromMilliseconds(15) < TimeStamp::Now()) {
+     printf_stderr("Compositor: Composite took %i ms.\n",
+                   15 + (int)(TimeStamp::Now() - mExpectedComposeTime).ToMilliseconds());
+   }
+ #endif
+ }
+ 
+ void
+-CompositorParent::ComposeToTarget(gfxContext* aTarget)
++CompositorParent::ComposeToTarget(DrawTarget* aTarget)
+ {
+   PROFILER_LABEL("CompositorParent", "ComposeToTarget");
+   AutoRestore<bool> override(mOverrideComposeReadiness);
+   mOverrideComposeReadiness = true;
+ 
+   if (!CanComposite()) {
+     return;
+   }
+-  mLayerManager->BeginTransactionWithTarget(aTarget);
++  mLayerManager->BeginTransactionWithDrawTarget(aTarget);
+   // Since CanComposite() is true, Composite() must end the layers txn
+   // we opened above.
+   Composite();
+ }
+ 
+ bool
+ CompositorParent::CanComposite()
+ {
+diff --git a/gfx/layers/ipc/CompositorParent.h b/gfx/layers/ipc/CompositorParent.h
+--- a/gfx/layers/ipc/CompositorParent.h
++++ b/gfx/layers/ipc/CompositorParent.h
+@@ -34,16 +34,20 @@
+ #include "nsSize.h"                     // for nsIntSize
+ 
+ class CancelableTask;
+ class MessageLoop;
+ class gfxContext;
+ class nsIWidget;
+ 
+ namespace mozilla {
++namespace gfx {
++class DrawTarget;
++}
++
+ namespace layers {
+ 
+ class APZCTreeManager;
+ class AsyncCompositionManager;
+ class LayerManagerComposite;
+ class LayerTransactionParent;
+ 
+ struct ScopedLayerTreeRegistration
+@@ -216,17 +220,17 @@ protected:
+   virtual PLayerTransactionParent*
+     AllocPLayerTransactionParent(const nsTArray<LayersBackend>& aBackendHints,
+                                  const uint64_t& aId,
+                                  TextureFactoryIdentifier* aTextureFactoryIdentifier,
+                                  bool* aSuccess);
+   virtual bool DeallocPLayerTransactionParent(PLayerTransactionParent* aLayers);
+   virtual void ScheduleTask(CancelableTask*, int);
+   virtual void Composite();
+-  virtual void ComposeToTarget(gfxContext* aTarget);
++  virtual void ComposeToTarget(gfx::DrawTarget* aTarget);
+ 
+   void SetEGLSurfaceSize(int width, int height);
+ 
+ private:
+   void InitializeLayerManager(const nsTArray<LayersBackend>& aBackendHints);
+   void PauseComposition();
+   void ResumeComposition();
+   void ResumeCompositionAndResize(int width, int height);
+diff --git a/gfx/layers/ipc/LayerTransactionParent.cpp b/gfx/layers/ipc/LayerTransactionParent.cpp
+--- a/gfx/layers/ipc/LayerTransactionParent.cpp
++++ b/gfx/layers/ipc/LayerTransactionParent.cpp
+@@ -195,17 +195,17 @@ LayerTransactionParent::RecvUpdate(const
+   MOZ_LAYERS_LOG(("[ParentSide] received txn with %d edits", cset.Length()));
+ 
+   if (mDestroyed || !layer_manager() || layer_manager()->IsDestroyed()) {
+     return true;
+   }
+ 
+   EditReplyVector replyv;
+ 
+-  layer_manager()->BeginTransactionWithTarget(nullptr);
++  layer_manager()->BeginTransactionWithDrawTarget(nullptr);
+ 
+   for (EditArray::index_type i = 0; i < cset.Length(); ++i) {
+     const Edit& edit = cset[i];
+ 
+     switch (edit.type()) {
+     // Create* ops
+     case Edit::TOpCreateThebesLayer: {
+       MOZ_LAYERS_LOG(("[ParentSide] CreateThebesLayer"));
+diff --git a/gfx/layers/opengl/CompositorOGL.cpp b/gfx/layers/opengl/CompositorOGL.cpp
+--- a/gfx/layers/opengl/CompositorOGL.cpp
++++ b/gfx/layers/opengl/CompositorOGL.cpp
+@@ -1256,21 +1256,20 @@ CompositorOGL::EndFrame()
+ #ifdef MOZ_DUMP_PAINTING
+   if (gfxUtils::sDumpPainting) {
+     nsIntRect rect;
+     if (mUseExternalSurfaceSize) {
+       rect = nsIntRect(0, 0, mSurfaceSize.width, mSurfaceSize.height);
+     } else {
+       mWidget->GetBounds(rect);
+     }
+-    nsRefPtr<gfxASurface> surf = gfxPlatform::GetPlatform()->CreateOffscreenSurface(rect.Size(), GFX_CONTENT_COLOR_ALPHA);
+-    nsRefPtr<gfxContext> ctx = new gfxContext(surf);
+-    CopyToTarget(ctx, mCurrentRenderTarget->GetTransform());
++    RefPtr<DrawTarget> target = gfxPlatform::GetPlatform()->CreateOffscreenContentDrawTarget(IntSize(rect.width, rect.height), FORMAT_B8G8R8A8);
++    CopyToTarget(target, mCurrentRenderTarget->GetTransform());
+ 
+-    WriteSnapshotToDumpFile(this, surf);
++    WriteSnapshotToDumpFile(this, target);
+   }
+ #endif
+ 
+   mFrameInProgress = false;
+ 
+   if (mTarget) {
+     CopyToTarget(mTarget, mCurrentRenderTarget->GetTransform());
+     mGLContext->fBindBuffer(LOCAL_GL_ARRAY_BUFFER, 0);
+@@ -1330,60 +1329,55 @@ CompositorOGL::AbortFrame()
+ void
+ CompositorOGL::SetDestinationSurfaceSize(const gfx::IntSize& aSize)
+ {
+   mSurfaceSize.width = aSize.width;
+   mSurfaceSize.height = aSize.height;
+ }
+ 
+ void
+-CompositorOGL::CopyToTarget(gfxContext *aTarget, const gfxMatrix& aTransform)
++CompositorOGL::CopyToTarget(DrawTarget *aTarget, const gfxMatrix& aTransform)
+ {
+-  nsIntRect rect;
++  IntRect rect;
+   if (mUseExternalSurfaceSize) {
+-    rect = nsIntRect(0, 0, mSurfaceSize.width, mSurfaceSize.height);
++    rect = IntRect(0, 0, mSurfaceSize.width, mSurfaceSize.height);
+   } else {
+-    rect = nsIntRect(0, 0, mWidgetSize.width, mWidgetSize.height);
++    rect = IntRect(0, 0, mWidgetSize.width, mWidgetSize.height);
+   }
+   GLint width = rect.width;
+   GLint height = rect.height;
+ 
+   if ((int64_t(width) * int64_t(height) * int64_t(4)) > PR_INT32_MAX) {
+     NS_ERROR("Widget size too big - integer overflow!");
+     return;
+   }
+ 
+-  nsRefPtr<gfxImageSurface> imageSurface =
+-    new gfxImageSurface(gfxIntSize(width, height),
+-                        gfxImageFormatARGB32);
+-
+   mGLContext->fBindFramebuffer(LOCAL_GL_FRAMEBUFFER, 0);
+ 
+   if (!mGLContext->IsGLES2()) {
+     // GLES2 promises that binding to any custom FBO will attach
+     // to GL_COLOR_ATTACHMENT0 attachment point.
+     mGLContext->fReadBuffer(LOCAL_GL_BACK);
+   }
+ 
+-  NS_ASSERTION(imageSurface->Stride() == width * 4,
+-               "Image Surfaces being created with weird stride!");
+-
+-  mGLContext->ReadPixelsIntoImageSurface(imageSurface);
++  RefPtr<SourceSurface> source =
++    mGLContext->ReadPixelsToSourceSurface(IntSize(width, height));
+ 
+   // Map from GL space to Cairo space and reverse the world transform.
+-  gfxMatrix glToCairoTransform = aTransform;
++  Matrix glToCairoTransform = MatrixForThebesMatrix(aTransform);
+   glToCairoTransform.Invert();
+   glToCairoTransform.Scale(1.0, -1.0);
+-  glToCairoTransform.Translate(-gfxPoint(0.0, height));
++  glToCairoTransform.Translate(0.0, -height);
+ 
+-  gfxContextAutoSaveRestore restore(aTarget);
+-  aTarget->SetOperator(gfxContext::OPERATOR_SOURCE);
+-  aTarget->SetMatrix(glToCairoTransform);
+-  aTarget->SetSource(imageSurface);
+-  aTarget->Paint();
++  Matrix oldMatrix = aTarget->GetTransform();
++  aTarget->SetTransform(glToCairoTransform);
++  Rect floatRect = Rect(rect.x, rect.y, rect.width, rect.height);
++  aTarget->DrawSurface(source, floatRect, floatRect, DrawSurfaceOptions(), DrawOptions(1.0f, OP_SOURCE));
++  aTarget->SetTransform(oldMatrix);
++  aTarget->Flush();
+ }
+ 
+ double
+ CompositorOGL::AddFrameAndGetFps(const TimeStamp& timestamp)
+ {
+   if (sDrawFPS) {
+     if (!mFPS) {
+       mFPS = new FPSState();
+diff --git a/gfx/layers/opengl/CompositorOGL.h b/gfx/layers/opengl/CompositorOGL.h
+--- a/gfx/layers/opengl/CompositorOGL.h
++++ b/gfx/layers/opengl/CompositorOGL.h
+@@ -5,32 +5,30 @@
+ 
+ #ifndef MOZILLA_GFX_COMPOSITOROGL_H
+ #define MOZILLA_GFX_COMPOSITOROGL_H
+ 
+ #include "GLContextTypes.h"             // for GLContext, etc
+ #include "GLDefs.h"                     // for GLuint, LOCAL_GL_TEXTURE_2D, etc
+ #include "LayerManagerOGLProgram.h"     // for ShaderProgramOGL, etc
+ #include "Units.h"                      // for ScreenPoint
+-#include "gfxContext.h"                 // for gfxContext
+-#include "gfxPoint.h"                   // for gfxIntSize
+ #include "mozilla/Assertions.h"         // for MOZ_ASSERT, etc
+ #include "mozilla/Attributes.h"         // for MOZ_OVERRIDE, MOZ_FINAL
+ #include "mozilla/RefPtr.h"             // for TemporaryRef, RefPtr
++#include "mozilla/gfx/2D.h"             // for DrawTarget
+ #include "mozilla/gfx/BaseSize.h"       // for BaseSize
+ #include "mozilla/gfx/Point.h"          // for IntSize, Point
+ #include "mozilla/gfx/Rect.h"           // for Rect, IntRect
+ #include "mozilla/gfx/Types.h"          // for Float, SurfaceFormat, etc
+ #include "mozilla/layers/Compositor.h"  // for SurfaceInitMode, Compositor, etc
+ #include "mozilla/layers/CompositorTypes.h"  // for MaskType::NumMaskTypes, etc
+ #include "mozilla/layers/LayersTypes.h"
+ #include "nsAutoPtr.h"                  // for nsRefPtr, nsAutoPtr
+ #include "nsCOMPtr.h"                   // for already_AddRefed
+ #include "nsDebug.h"                    // for NS_ASSERTION, NS_WARNING
+-#include "nsISupportsImpl.h"            // for gfxContext::AddRef, etc
+ #include "nsSize.h"                     // for nsIntSize
+ #include "nsTArray.h"                   // for nsAutoTArray, nsTArray, etc
+ #include "nsThreadUtils.h"              // for nsRunnable
+ #include "nsTraceRefcnt.h"              // for MOZ_COUNT_CTOR, etc
+ #include "nsXULAppAPI.h"                // for XRE_GetProcessType
+ #include "nscore.h"                     // for NS_IMETHOD
+ #include "VBOArena.h"                   // for gl::VBOArena
+ 
+@@ -101,39 +99,39 @@ public:
+                         const gfx::Point& aOffset) MOZ_OVERRIDE;
+ 
+   virtual void EndFrame() MOZ_OVERRIDE;
+   virtual void EndFrameForExternalComposition(const gfxMatrix& aTransform) MOZ_OVERRIDE;
+   virtual void AbortFrame() MOZ_OVERRIDE;
+ 
+   virtual bool SupportsPartialTextureUpdate() MOZ_OVERRIDE;
+ 
+-  virtual bool CanUseCanvasLayerForSize(const gfxIntSize &aSize) MOZ_OVERRIDE
++  virtual bool CanUseCanvasLayerForSize(const gfx::IntSize &aSize) MOZ_OVERRIDE
+   {
+     if (!mGLContext)
+       return false;
+     int32_t maxSize = GetMaxTextureSize();
+-    return aSize <= gfxIntSize(maxSize, maxSize);
++    return aSize <= gfx::IntSize(maxSize, maxSize);
+   }
+ 
+   virtual int32_t GetMaxTextureSize() const MOZ_OVERRIDE;
+ 
+   /**
+    * Set the size of the EGL surface we're rendering to, if we're rendering to
+    * an EGL surface.
+    */
+   virtual void SetDestinationSurfaceSize(const gfx::IntSize& aSize) MOZ_OVERRIDE;
+ 
+   virtual void SetScreenRenderOffset(const ScreenPoint& aOffset) MOZ_OVERRIDE {
+     mRenderOffset = aOffset;
+   }
+ 
+   virtual void MakeCurrent(MakeCurrentFlags aFlags = 0) MOZ_OVERRIDE;
+ 
+-  virtual void SetTargetContext(gfxContext* aTarget) MOZ_OVERRIDE
++  virtual void SetTargetContext(gfx::DrawTarget* aTarget) MOZ_OVERRIDE
+   {
+     mTarget = aTarget;
+   }
+ 
+   virtual void PrepareViewport(const gfx::IntSize& aSize,
+                                const gfxMatrix& aWorldTransform) MOZ_OVERRIDE;
+ 
+ 
+@@ -166,17 +164,17 @@ public:
+    * Doing so lets us use gralloc the way it has been designed to be used
+    * (see https://wiki.mozilla.org/Platform/GFX/Gralloc)
+    */
+   GLuint GetTemporaryTexture(GLenum aUnit);
+ private:
+   /** 
+    * Context target, nullptr when drawing directly to our swap chain.
+    */
+-  nsRefPtr<gfxContext> mTarget;
++  RefPtr<gfx::DrawTarget> mTarget;
+ 
+   /** Widget associated with this compositor */
+   nsIWidget *mWidget;
+   nsIntSize mWidgetSize;
+   nsRefPtr<GLContext> mGLContext;
+ 
+   /** The size of the surface we are rendering to */
+   nsIntSize mSurfaceSize;
+@@ -295,17 +293,17 @@ private:
+                                       TextureSource *aTexture);
+ 
+   void CleanupResources();
+ 
+   /**
+    * Copies the content of our backbuffer to the set transaction target.
+    * Does not restore the target FBO, so only call from EndFrame.
+    */
+-  void CopyToTarget(gfxContext *aTarget, const gfxMatrix& aWorldMatrix);
++  void CopyToTarget(gfx::DrawTarget* aTarget, const gfxMatrix& aWorldMatrix);
+ 
+   /**
+    * Records the passed frame timestamp and returns the current estimated FPS.
+    */
+   double AddFrameAndGetFps(const TimeStamp& timestamp);
+ 
+   bool mDestroyed;
+ 
+diff --git a/gfx/thebes/gfx2DGlue.h b/gfx/thebes/gfx2DGlue.h
+--- a/gfx/thebes/gfx2DGlue.h
++++ b/gfx/thebes/gfx2DGlue.h
+@@ -194,16 +194,22 @@ inline JoinStyle ToJoinStyle(gfxContext:
+ }
+ 
+ inline gfxMatrix ThebesMatrix(const Matrix &aMatrix)
+ {
+   return gfxMatrix(aMatrix._11, aMatrix._12, aMatrix._21,
+                    aMatrix._22, aMatrix._31, aMatrix._32);
+ }
+ 
++inline Matrix MatrixForThebesMatrix(const gfxMatrix &aMatrix)
++{
++  return Matrix(aMatrix.xx, aMatrix.yx, aMatrix.xy,
++                aMatrix.yy, aMatrix.x0, aMatrix.y0);
++}
++
+ inline gfxImageFormat SurfaceFormatToImageFormat(SurfaceFormat aFormat)
+ {
+   switch (aFormat) {
+   case FORMAT_B8G8R8A8:
+     return gfxImageFormatARGB32;
+   case FORMAT_B8G8R8X8:
+     return gfxImageFormatRGB24;
+   case FORMAT_R5G6B5:
+
--- a/tests/unit.py	Sat Sep 28 05:15:59 2013 -0700
+++ b/tests/unit.py	Sat Sep 28 06:40:25 2013 -0700
@@ -18,7 +18,8 @@
     def test_patch(self):
         """test parsing the files from a patch"""
 
-        files = 
+        diff = os.path.join(here, '41701d2c0341.diff')
+        files = FeedAgentDiff.lsdiff(diff)
 
 if __name__ == '__main__':
     unittest.main()