diff -r 000000000000 -r 6474c204b198 gfx/layers/d3d9/CanvasLayerD3D9.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gfx/layers/d3d9/CanvasLayerD3D9.cpp	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,212 @@
+/* -*- 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/. */
+
+
+#include "mozilla/layers/PLayerTransaction.h"
+
+#include "gfxWindowsSurface.h"
+#include "gfxWindowsPlatform.h"
+#include "SurfaceStream.h"
+#include "SharedSurfaceGL.h"
+#include "GLContext.h"
+#include "CanvasLayerD3D9.h"
+
+using namespace mozilla::gfx;
+using namespace mozilla::gl;
+
+namespace mozilla {
+namespace layers {
+
+CanvasLayerD3D9::CanvasLayerD3D9(LayerManagerD3D9 *aManager)
+  : CanvasLayer(aManager, nullptr)
+  , LayerD3D9(aManager)
+  , mDataIsPremultiplied(false)
+  , mNeedsYFlip(false)
+  , mHasAlpha(true)
+{
+    mImplData = static_cast<LayerD3D9*>(this);
+    aManager->deviceManager()->mLayersWithResources.AppendElement(this);
+}
+
+CanvasLayerD3D9::~CanvasLayerD3D9()
+{
+  if (mD3DManager) {
+    mD3DManager->deviceManager()->mLayersWithResources.RemoveElement(this);
+  }
+}
+
+void
+CanvasLayerD3D9::Initialize(const Data& aData)
+{
+  NS_ASSERTION(mDrawTarget == nullptr, "BasicCanvasLayer::Initialize called twice!");
+
+  if (aData.mDrawTarget) {
+    mDrawTarget = aData.mDrawTarget;
+    mNeedsYFlip = false;
+    mDataIsPremultiplied = true;
+  } else if (aData.mGLContext) {
+    mGLContext = aData.mGLContext;
+    NS_ASSERTION(mGLContext->IsOffscreen(), "Canvas GLContext must be offscreen.");
+    mDataIsPremultiplied = aData.mIsGLAlphaPremult;
+    mNeedsYFlip = true;
+  } else {
+    NS_ERROR("CanvasLayer created without mGLContext or mDrawTarget?");
+  }
+
+  mBounds.SetRect(0, 0, aData.mSize.width, aData.mSize.height);
+
+  CreateTexture();
+}
+
+void
+CanvasLayerD3D9::UpdateSurface()
+{
+  if (!IsDirty() && mTexture)
+    return;
+  Painted();
+
+  if (!mTexture) {
+    CreateTexture();
+
+    if (!mTexture) {
+      NS_WARNING("CanvasLayerD3D9::Updated called but no texture present and creation failed!");
+      return;
+    }
+  }
+
+  RefPtr<SourceSurface> surface;
+
+  if (mGLContext) {
+    SharedSurface_GL* surf = mGLContext->RequestFrame();
+    if (!surf)
+        return;
+
+    SharedSurface_Basic* shareSurf = SharedSurface_Basic::Cast(surf);
+    surface = shareSurf->GetData();
+  } else {
+    surface = mDrawTarget->Snapshot();
+  }
+
+  // WebGL reads entire surface.
+  LockTextureRectD3D9 textureLock(mTexture);
+  if (!textureLock.HasLock()) {
+    NS_WARNING("Failed to lock CanvasLayer texture.");
+    return;
+  }
+
+  D3DLOCKED_RECT rect = textureLock.GetLockRect();
+  IntSize boundsSize(mBounds.width, mBounds.height);
+  RefPtr<DrawTarget> rectDt = Factory::CreateDrawTargetForData(BackendType::CAIRO,
+                                                               (uint8_t*)rect.pBits,
+                                                               boundsSize,
+                                                               rect.Pitch,
+                                                               SurfaceFormat::B8G8R8A8);
+
+  Rect drawRect(0, 0, surface->GetSize().width, surface->GetSize().height);
+  rectDt->DrawSurface(surface, drawRect, drawRect,
+                      DrawSurfaceOptions(),  DrawOptions(1.0F, CompositionOp::OP_SOURCE));
+  rectDt->Flush();
+}
+
+Layer*
+CanvasLayerD3D9::GetLayer()
+{
+  return this;
+}
+
+void
+CanvasLayerD3D9::RenderLayer()
+{
+  FirePreTransactionCallback();
+  UpdateSurface();
+  if (mD3DManager->CompositingDisabled()) {
+    return;
+  }
+  FireDidTransactionCallback();
+
+  if (!mTexture)
+    return;
+
+  /*
+   * We flip the Y axis here, note we can only do this because we are in
+   * CULL_NONE mode!
+   */
+
+  ShaderConstantRect quad(0, 0, mBounds.width, mBounds.height);
+  if (mNeedsYFlip) {
+    quad.mHeight = (float)-mBounds.height;
+    quad.mY = (float)mBounds.height;
+  }
+
+  device()->SetVertexShaderConstantF(CBvLayerQuad, quad, 1);
+
+  SetShaderTransformAndOpacity();
+
+  if (mHasAlpha) {
+    mD3DManager->SetShaderMode(DeviceManagerD3D9::RGBALAYER, GetMaskLayer());
+  } else {
+    mD3DManager->SetShaderMode(DeviceManagerD3D9::RGBLAYER, GetMaskLayer());
+  }
+
+  if (mFilter == GraphicsFilter::FILTER_NEAREST) {
+    device()->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
+    device()->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_POINT);
+  }
+  if (!mDataIsPremultiplied) {
+    device()->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
+    device()->SetRenderState(D3DRS_SEPARATEALPHABLENDENABLE, TRUE);
+  }
+  device()->SetTexture(0, mTexture);
+  device()->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, 2);
+  if (!mDataIsPremultiplied) {
+    device()->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_ONE);
+    device()->SetRenderState(D3DRS_SEPARATEALPHABLENDENABLE, FALSE);
+  }
+  if (mFilter == GraphicsFilter::FILTER_NEAREST) {
+    device()->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
+    device()->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
+  }
+}
+
+void
+CanvasLayerD3D9::CleanResources()
+{
+  if (mD3DManager->deviceManager()->HasDynamicTextures()) {
+    // In this case we have a texture in POOL_DEFAULT
+    mTexture = nullptr;
+  }
+}
+
+void
+CanvasLayerD3D9::LayerManagerDestroyed()
+{
+  mD3DManager->deviceManager()->mLayersWithResources.RemoveElement(this);
+  mD3DManager = nullptr;
+}
+
+void
+CanvasLayerD3D9::CreateTexture()
+{
+  HRESULT hr;
+  if (mD3DManager->deviceManager()->HasDynamicTextures()) {
+    hr = device()->CreateTexture(mBounds.width, mBounds.height, 1, D3DUSAGE_DYNAMIC,
+                                 D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT,
+                                 getter_AddRefs(mTexture), nullptr);
+  } else {
+    // D3DPOOL_MANAGED is fine here since we require Dynamic Textures for D3D9Ex
+    // devices.
+    hr = device()->CreateTexture(mBounds.width, mBounds.height, 1, 0,
+                                 D3DFMT_A8R8G8B8, D3DPOOL_MANAGED,
+                                 getter_AddRefs(mTexture), nullptr);
+  }
+  if (FAILED(hr)) {
+    mD3DManager->ReportFailure(NS_LITERAL_CSTRING("CanvasLayerD3D9::CreateTexture() failed"),
+                                 hr);
+    return;
+  }
+}
+
+} /* namespace layers */
+} /* namespace mozilla */