The Tor Browser: comparison gfx/layers/d3d10/ReadbackManagerD3D10.cpp

--1:000000000000
+:bafe9cf6e3f4
+/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+* 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 "ReadbackManagerD3D10.h"
+#include "ReadbackProcessor.h"
+#include "ReadbackLayer.h"
+#include "nsIThread.h"
+#include "nsThreadUtils.h"
+#include "gfxImageSurface.h"
+#include "gfxContext.h"
+namespace mozilla {
+namespace layers {
+// Structure that contains the information required to execute a readback task,
+// the only member accessed off the main thread here is mReadbackTexture. Since
+// mLayer may be released only on the main thread this object should always be
+// destroyed on the main thread!
+struct ReadbackTask {
+// The texture that we copied the contents of the thebeslayer to.
+nsRefPtr<ID3D10Texture2D> mReadbackTexture;
+// This exists purely to keep the ReadbackLayer alive for the lifetime of
+// mUpdate. Note that this addref and release should occur -solely- on the
+// main thread.
+nsRefPtr<ReadbackLayer> mLayer;
+ReadbackProcessor::Update mUpdate;
+// The origin in ThebesLayer coordinates of mReadbackTexture.
+gfxPoint mOrigin;
+// mLayer->GetBackgroundOffset() when the task is created.  We have
+// to save this in the ReadbackTask because it might change before
+// the update is delivered to the readback sink.
+nsIntPoint mBackgroundOffset;
+};
+// This class is created and dispatched from the Readback thread but it must be
+// destroyed by the main thread.
+class ReadbackResultWriter MOZ_FINAL : public nsIRunnable
+{
+NS_DECL_THREADSAFE_ISUPPORTS
+public:
+ReadbackResultWriter(ReadbackTask *aTask) : mTask(aTask) {}
+NS_IMETHODIMP Run()
+{
+ReadbackProcessor::Update *update = &mTask->mUpdate;
+if (!update->mLayer->GetSink()) {
+// This can happen when a plugin is destroyed.
+return NS_OK;
+}
+nsIntPoint offset = mTask->mBackgroundOffset;
+D3D10_TEXTURE2D_DESC desc;
+mTask->mReadbackTexture->GetDesc(&desc);
+D3D10_MAPPED_TEXTURE2D mappedTex;
+// We know this map will immediately succeed, as we've already mapped this
+// copied data on our task thread.
+HRESULT hr = mTask->mReadbackTexture->Map(0, D3D10_MAP_READ, 0, &mappedTex);
+if (FAILED(hr)) {
+// If this fails we're never going to get our ThebesLayer content.
+update->mLayer->GetSink()->SetUnknown(update->mSequenceCounter);
+return NS_OK;
+}
+nsRefPtr<gfxImageSurface> sourceSurface =
+new gfxImageSurface((unsigned char*)mappedTex.pData,
+gfxIntSize(desc.Width, desc.Height),
+mappedTex.RowPitch,
+gfxImageFormat::RGB24);
+nsRefPtr<gfxContext> ctx =
+update->mLayer->GetSink()->BeginUpdate(update->mUpdateRect + offset,
+update->mSequenceCounter);
+if (ctx) {
+ctx->Translate(gfxPoint(offset.x, offset.y));
+ctx->SetSource(sourceSurface, gfxPoint(mTask->mOrigin.x,
+mTask->mOrigin.y));
+ctx->Paint();
+update->mLayer->GetSink()->EndUpdate(ctx, update->mUpdateRect + offset);
+}
+mTask->mReadbackTexture->Unmap(0);
+return NS_OK;
+}
+private:
+nsAutoPtr<ReadbackTask> mTask;
+};
+NS_IMPL_ISUPPORTS(ReadbackResultWriter, nsIRunnable)
+DWORD WINAPI StartTaskThread(void *aManager)
+{
+static_cast<ReadbackManagerD3D10*>(aManager)->ProcessTasks();
+return 0;
+}
+ReadbackManagerD3D10::ReadbackManagerD3D10()
+: mRefCnt(0)
+{
+::InitializeCriticalSection(&mTaskMutex);
+mShutdownEvent = ::CreateEventA(nullptr, FALSE, FALSE, nullptr);
+mTaskSemaphore = ::CreateSemaphoreA(nullptr, 0, 1000000, nullptr);
+mTaskThread = ::CreateThread(nullptr, 0, StartTaskThread, this, 0, 0);
+}
+ReadbackManagerD3D10::~ReadbackManagerD3D10()
+{
+::SetEvent(mShutdownEvent);
+// This shouldn't take longer than 5 seconds, if it does we're going to choose
+// to leak the thread and its synchronisation in favor of crashing or freezing
+DWORD result = ::WaitForSingleObject(mTaskThread, 5000);
+if (result != WAIT_TIMEOUT) {
+::DeleteCriticalSection(&mTaskMutex);
+::CloseHandle(mShutdownEvent);
+::CloseHandle(mTaskSemaphore);
+::CloseHandle(mTaskThread);
+} else {
+NS_RUNTIMEABORT("ReadbackManager: Task thread did not shutdown in 5 seconds.");
+}
+}
+void
+ReadbackManagerD3D10::PostTask(ID3D10Texture2D *aTexture, void *aUpdate, const gfxPoint &aOrigin)
+{
+ReadbackTask *task = new ReadbackTask;
+task->mReadbackTexture = aTexture;
+task->mUpdate = *static_cast<ReadbackProcessor::Update*>(aUpdate);
+task->mOrigin = aOrigin;
+task->mLayer = task->mUpdate.mLayer;
+task->mBackgroundOffset = task->mLayer->GetBackgroundLayerOffset();
+::EnterCriticalSection(&mTaskMutex);
+mPendingReadbackTasks.AppendElement(task);
+::LeaveCriticalSection(&mTaskMutex);
+::ReleaseSemaphore(mTaskSemaphore, 1, nullptr);
+}
+HRESULT
+ReadbackManagerD3D10::QueryInterface(REFIID riid, void **ppvObject)
+{
+if (!ppvObject) {
+return E_POINTER;
+}
+if (riid == IID_IUnknown) {
+*ppvObject = this;
+} else {
+return E_NOINTERFACE;
+}
+return S_OK;
+}
+ULONG
+ReadbackManagerD3D10::AddRef()
+{
+NS_ASSERTION(NS_IsMainThread(),
+"ReadbackManagerD3D10 should only be refcounted on main thread.");
+return ++mRefCnt;
+}
+ULONG
+ReadbackManagerD3D10::Release()
+{
+NS_ASSERTION(NS_IsMainThread(),
+"ReadbackManagerD3D10 should only be refcounted on main thread.");
+ULONG newRefCnt = --mRefCnt;
+if (!newRefCnt) {
+mRefCnt++;
+delete this;
+}
+return newRefCnt;
+}
+void
+ReadbackManagerD3D10::ProcessTasks()
+{
+HANDLE handles[] = { mTaskSemaphore, mShutdownEvent };
+while (true) {
+DWORD result = ::WaitForMultipleObjects(2, handles, FALSE, INFINITE);
+if (result != WAIT_OBJECT_0) {
+return;
+}
+::EnterCriticalSection(&mTaskMutex);
+if (mPendingReadbackTasks.Length() == 0) {
+NS_RUNTIMEABORT("Trying to read from an empty array, bad bad bad");
+}
+ReadbackTask *nextReadbackTask = mPendingReadbackTasks[0].forget();
+mPendingReadbackTasks.RemoveElementAt(0);
+::LeaveCriticalSection(&mTaskMutex);
+// We want to block here until the texture contents are available, the
+// easiest thing is to simply map and unmap.
+D3D10_MAPPED_TEXTURE2D mappedTex;
+nextReadbackTask->mReadbackTexture->Map(0, D3D10_MAP_READ, 0, &mappedTex);
+nextReadbackTask->mReadbackTexture->Unmap(0);
+// We can only send the update to the sink on the main thread, so post an
+// event there to do so. Ownership of the task is passed from
+// mPendingReadbackTasks to ReadbackResultWriter here.
+nsCOMPtr<nsIThread> thread = do_GetMainThread();
+thread->Dispatch(new ReadbackResultWriter(nextReadbackTask),
+nsIEventTarget::DISPATCH_NORMAL);
+}
+}
+}
+}

The Tor Browser / file comparison

comparison: gfx/layers/d3d10/ReadbackManagerD3D10.cpp

gfx/layers/d3d10/ReadbackManagerD3D10.cpp