diff -r 000000000000 -r 6474c204b198 gfx/layers/D3D9SurfaceImage.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gfx/layers/D3D9SurfaceImage.cpp	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,204 @@
+/* -*- 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 "D3D9SurfaceImage.h"
+#include "gfx2DGlue.h"
+#include "mozilla/layers/TextureD3D9.h"
+#include "mozilla/gfx/Types.h"
+
+namespace mozilla {
+namespace layers {
+
+
+D3D9SurfaceImage::D3D9SurfaceImage()
+  : Image(nullptr, ImageFormat::D3D9_RGB32_TEXTURE)
+  , mSize(0, 0)
+{}
+
+D3D9SurfaceImage::~D3D9SurfaceImage() {}
+
+HRESULT
+D3D9SurfaceImage::SetData(const Data& aData)
+{
+  NS_ENSURE_TRUE(aData.mSurface, E_POINTER);
+  HRESULT hr;
+  RefPtr<IDirect3DSurface9> surface = aData.mSurface;
+
+  RefPtr<IDirect3DDevice9> device;
+  hr = surface->GetDevice(byRef(device));
+  NS_ENSURE_TRUE(SUCCEEDED(hr), E_FAIL);
+
+  RefPtr<IDirect3D9> d3d9;
+  hr = device->GetDirect3D(byRef(d3d9));
+  NS_ENSURE_TRUE(SUCCEEDED(hr), E_FAIL);
+
+  D3DSURFACE_DESC desc;
+  surface->GetDesc(&desc);
+  // Ensure we can convert the textures format to RGB conversion
+  // in StretchRect. Fail if we can't.
+  hr = d3d9->CheckDeviceFormatConversion(D3DADAPTER_DEFAULT,
+                                         D3DDEVTYPE_HAL,
+                                         desc.Format,
+                                         D3DFMT_X8R8G8B8);
+  NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
+
+  // DXVA surfaces aren't created sharable, so we need to copy the surface
+  // to a sharable texture to that it's accessible to the layer manager's
+  // device.
+  const nsIntRect& region = aData.mRegion;
+  RefPtr<IDirect3DTexture9> texture;
+  HANDLE shareHandle = nullptr;
+  hr = device->CreateTexture(region.width,
+                             region.height,
+                             1,
+                             D3DUSAGE_RENDERTARGET,
+                             D3DFMT_X8R8G8B8,
+                             D3DPOOL_DEFAULT,
+                             byRef(texture),
+                             &shareHandle);
+  NS_ENSURE_TRUE(SUCCEEDED(hr) && shareHandle, hr);
+
+  // Copy the image onto the texture, preforming YUV -> RGB conversion if necessary.
+  RefPtr<IDirect3DSurface9> textureSurface;
+  hr = texture->GetSurfaceLevel(0, byRef(textureSurface));
+  NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
+
+  // Stash the surface description for later use.
+  textureSurface->GetDesc(&mDesc);
+
+  RECT src = { region.x, region.y, region.x+region.width, region.y+region.height };
+  hr = device->StretchRect(surface, &src, textureSurface, nullptr, D3DTEXF_NONE);
+  NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
+
+  // Flush the draw command now, so that by the time we come to draw this
+  // image, we're less likely to need to wait for the draw operation to
+  // complete.
+  RefPtr<IDirect3DQuery9> query;
+  hr = device->CreateQuery(D3DQUERYTYPE_EVENT, byRef(query));
+  NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
+  hr = query->Issue(D3DISSUE_END);
+  NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
+
+  mTexture = texture;
+  mShareHandle = shareHandle;
+  mSize = gfx::IntSize(region.width, region.height);
+  mQuery = query;
+
+  return S_OK;
+}
+
+void
+D3D9SurfaceImage::EnsureSynchronized()
+{
+  if (!mQuery) {
+    // Not setup, or already synchronized.
+    return;
+  }
+  int iterations = 0;
+  while (iterations < 10 && S_FALSE == mQuery->GetData(nullptr, 0, D3DGETDATA_FLUSH)) {
+    Sleep(1);
+    iterations++;
+  }
+  mQuery = nullptr;
+}
+
+HANDLE
+D3D9SurfaceImage::GetShareHandle()
+{
+  // Ensure the image has completed its synchronization,
+  // and safe to used by the caller on another device.
+  EnsureSynchronized();
+  return mShareHandle;
+}
+
+const D3DSURFACE_DESC&
+D3D9SurfaceImage::GetDesc() const
+{
+  return mDesc;
+}
+
+gfx::IntSize
+D3D9SurfaceImage::GetSize()
+{
+  return mSize;
+}
+
+TextureClient*
+D3D9SurfaceImage::GetTextureClient(CompositableClient* aClient)
+{
+  EnsureSynchronized();
+  if (!mTextureClient) {
+    RefPtr<SharedTextureClientD3D9> textureClient =
+      new SharedTextureClientD3D9(gfx::SurfaceFormat::B8G8R8X8, TEXTURE_FLAGS_DEFAULT);
+    textureClient->InitWith(mTexture, mShareHandle, mDesc);
+    mTextureClient = textureClient;
+  }
+  return mTextureClient;
+}
+
+TemporaryRef<gfx::SourceSurface>
+D3D9SurfaceImage::GetAsSourceSurface()
+{
+  NS_ENSURE_TRUE(mTexture, nullptr);
+
+  HRESULT hr;
+  RefPtr<gfx::DataSourceSurface> surface = gfx::Factory::CreateDataSourceSurface(mSize, gfx::SurfaceFormat::B8G8R8X8);
+
+  if (!surface) {
+    NS_WARNING("Failed to created SourceSurface for D3D9SurfaceImage.");
+    return nullptr;
+  }
+
+  // Ensure that the texture is ready to be used.
+  EnsureSynchronized();
+
+  // Readback the texture from GPU memory into system memory, so that
+  // we can copy it into the Cairo image. This is expensive.
+  RefPtr<IDirect3DSurface9> textureSurface;
+  hr = mTexture->GetSurfaceLevel(0, byRef(textureSurface));
+  NS_ENSURE_TRUE(SUCCEEDED(hr), nullptr);
+
+  RefPtr<IDirect3DDevice9> device;
+  hr = mTexture->GetDevice(byRef(device));
+  NS_ENSURE_TRUE(SUCCEEDED(hr), nullptr);
+
+  RefPtr<IDirect3DSurface9> systemMemorySurface;
+  hr = device->CreateOffscreenPlainSurface(mDesc.Width,
+                                           mDesc.Height,
+                                           D3DFMT_X8R8G8B8,
+                                           D3DPOOL_SYSTEMMEM,
+                                           byRef(systemMemorySurface),
+                                           0);
+  NS_ENSURE_TRUE(SUCCEEDED(hr), nullptr);
+
+  hr = device->GetRenderTargetData(textureSurface, systemMemorySurface);
+  NS_ENSURE_TRUE(SUCCEEDED(hr), nullptr);
+
+  D3DLOCKED_RECT rect;
+  hr = systemMemorySurface->LockRect(&rect, nullptr, 0);
+  NS_ENSURE_TRUE(SUCCEEDED(hr), nullptr);
+
+  gfx::DataSourceSurface::MappedSurface mappedSurface;
+  if (!surface->Map(gfx::DataSourceSurface::WRITE, &mappedSurface)) {
+    systemMemorySurface->UnlockRect();
+    return nullptr;
+  }
+
+  const unsigned char* src = (const unsigned char*)(rect.pBits);
+  const unsigned srcPitch = rect.Pitch;
+  for (int y = 0; y < mSize.height; y++) {
+    memcpy(mappedSurface.mData + mappedSurface.mStride * y,
+           (unsigned char*)(src) + srcPitch * y,
+           mSize.width * 4);
+  }
+
+  systemMemorySurface->UnlockRect();
+  surface->Unmap();
+
+  return surface;
+}
+
+} /* layers */
+} /* mozilla */