The Tor Browser: gfx/layers/d3d11/TextureD3D11.cpp@129ffea94266 (annotated)

gfx/layers/d3d11/TextureD3D11.cpp@129ffea94266 (annotated)

gfx/layers/d3d11/TextureD3D11.cpp

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /* -*- 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 "TextureD3D11.h"
 #include "CompositorD3D11.h"
 #include "gfxContext.h"
 #include "Effects.h"
 #include "mozilla/layers/YCbCrImageDataSerializer.h"
 #include "gfxWindowsPlatform.h"
 #include "gfxD2DSurface.h"
 #include "gfx2DGlue.h"
 namespace mozilla {
 using namespace gfx;
 namespace layers {
 static DXGI_FORMAT
 SurfaceFormatToDXGIFormat(gfx::SurfaceFormat aFormat)
 {
   switch (aFormat) {
     case SurfaceFormat::B8G8R8A8:
       return DXGI_FORMAT_B8G8R8A8_UNORM;
     case SurfaceFormat::B8G8R8X8:
       return DXGI_FORMAT_B8G8R8A8_UNORM;
     case SurfaceFormat::A8:
       return DXGI_FORMAT_A8_UNORM;
     default:
       MOZ_ASSERT(false, "unsupported format");
       return DXGI_FORMAT_UNKNOWN;
   }
 }
 static uint32_t
 GetRequiredTilesD3D11(uint32_t aSize, uint32_t aMaxSize)
 {
   uint32_t requiredTiles = aSize / aMaxSize;
   if (aSize % aMaxSize) {
     requiredTiles++;
   }
   return requiredTiles;
 }
 static IntRect
 GetTileRectD3D11(uint32_t aID, IntSize aSize, uint32_t aMaxSize)
 {
   uint32_t horizontalTiles = GetRequiredTilesD3D11(aSize.width, aMaxSize);
   uint32_t verticalTiles = GetRequiredTilesD3D11(aSize.height, aMaxSize);
   uint32_t verticalTile = aID / horizontalTiles;
   uint32_t horizontalTile = aID % horizontalTiles;
   return IntRect(horizontalTile * aMaxSize,
                  verticalTile * aMaxSize,
                  horizontalTile < (horizontalTiles - 1) ? aMaxSize : aSize.width % aMaxSize,
                  verticalTile < (verticalTiles - 1) ? aMaxSize : aSize.height % aMaxSize);
 }
 DataTextureSourceD3D11::DataTextureSourceD3D11(SurfaceFormat aFormat,
                                                CompositorD3D11* aCompositor,
                                                TextureFlags aFlags)
   : mCompositor(aCompositor)
   , mFormat(aFormat)
   , mFlags(aFlags)
   , mCurrentTile(0)
   , mIsTiled(false)
   , mIterating(false)
 {
   MOZ_COUNT_CTOR(DataTextureSourceD3D11);
 }
 DataTextureSourceD3D11::DataTextureSourceD3D11(SurfaceFormat aFormat,
                                                CompositorD3D11* aCompositor,
                                                ID3D11Texture2D* aTexture)
 : mCompositor(aCompositor)
 , mFormat(aFormat)
 , mFlags(0)
 , mCurrentTile(0)
 , mIsTiled(false)
 , mIterating(false)
 {
   MOZ_COUNT_CTOR(DataTextureSourceD3D11);
   mTexture = aTexture;
   D3D11_TEXTURE2D_DESC desc;
   aTexture->GetDesc(&desc);
   mSize = IntSize(desc.Width, desc.Height);
 }
 DataTextureSourceD3D11::~DataTextureSourceD3D11()
 {
   MOZ_COUNT_DTOR(DataTextureSourceD3D11);
 }
 template<typename T> // ID3D10Texture2D or ID3D11Texture2D
 static void LockD3DTexture(T* aTexture)
 {
   MOZ_ASSERT(aTexture);
   RefPtr<IDXGIKeyedMutex> mutex;
   aTexture->QueryInterface((IDXGIKeyedMutex**)byRef(mutex));
   if (mutex) {
     mutex->AcquireSync(0, INFINITE);
   }
 }
 template<typename T> // ID3D10Texture2D or ID3D11Texture2D
 static void UnlockD3DTexture(T* aTexture)
 {
   MOZ_ASSERT(aTexture);
   RefPtr<IDXGIKeyedMutex> mutex;
   aTexture->QueryInterface((IDXGIKeyedMutex**)byRef(mutex));
   if (mutex) {
     mutex->ReleaseSync(0);
   }
 }
 TemporaryRef<TextureHost>
 CreateTextureHostD3D11(const SurfaceDescriptor& aDesc,
                        ISurfaceAllocator* aDeallocator,
                        TextureFlags aFlags)
 {
   RefPtr<TextureHost> result;
   switch (aDesc.type()) {
     case SurfaceDescriptor::TSurfaceDescriptorShmem:
     case SurfaceDescriptor::TSurfaceDescriptorMemory: {
       result = CreateBackendIndependentTextureHost(aDesc, aDeallocator, aFlags);
       break;
     }
     case SurfaceDescriptor::TSurfaceDescriptorD3D10: {
       result = new DXGITextureHostD3D11(aFlags,
                                         aDesc.get_SurfaceDescriptorD3D10());
       break;
     }
     default: {
       NS_WARNING("Unsupported SurfaceDescriptor type");
     }
   }
   return result;
 }
 TextureClientD3D11::TextureClientD3D11(gfx::SurfaceFormat aFormat, TextureFlags aFlags)
   : TextureClient(aFlags)
   , mFormat(aFormat)
   , mIsLocked(false)
   , mNeedsClear(false)
 {}
 TextureClientD3D11::~TextureClientD3D11()
 {
 #ifdef DEBUG
   // An Azure DrawTarget needs to be locked when it gets nullptr'ed as this is
   // when it calls EndDraw. This EndDraw should not execute anything so it
   // shouldn't -really- need the lock but the debug layer chokes on this.
   if (mDrawTarget) {
     MOZ_ASSERT(!mIsLocked);
     MOZ_ASSERT(mTexture);
     MOZ_ASSERT(mDrawTarget->refCount() == 1);
     LockD3DTexture(mTexture.get());
     mDrawTarget = nullptr;
     UnlockD3DTexture(mTexture.get());
   }
 #endif
 }
 bool
 TextureClientD3D11::Lock(OpenMode aMode)
 {
   if (!mTexture) {
     return false;
   }
   MOZ_ASSERT(!mIsLocked, "The Texture is already locked!");
   LockD3DTexture(mTexture.get());
   mIsLocked = true;
   if (mNeedsClear) {
     mDrawTarget = GetAsDrawTarget();
     mDrawTarget->ClearRect(Rect(0, 0, GetSize().width, GetSize().height));
     mNeedsClear = false;
   }
   return true;
 }
 void
 TextureClientD3D11::Unlock()
 {
   MOZ_ASSERT(mIsLocked, "Unlocked called while the texture is not locked!");
   if (mDrawTarget) {
     // see the comment on TextureClient::GetAsDrawTarget.
     // This DrawTarget is internal to the TextureClient and is only exposed to the
     // outside world between Lock() and Unlock(). This assertion checks that no outside
     // reference remains by the time Unlock() is called.
     MOZ_ASSERT(mDrawTarget->refCount() == 1);
     mDrawTarget->Flush();
   }
   // The DrawTarget is created only once, and is only usable between calls
   // to Lock and Unlock.
   UnlockD3DTexture(mTexture.get());
   mIsLocked = false;
 }
 TemporaryRef<DrawTarget>
 TextureClientD3D11::GetAsDrawTarget()
 {
   MOZ_ASSERT(mIsLocked, "Calling TextureClient::GetAsDrawTarget without locking :(");
   if (!mTexture) {
     return nullptr;
   }
   if (mDrawTarget) {
     return mDrawTarget;
   }
   mDrawTarget = Factory::CreateDrawTargetForD3D10Texture(mTexture, mFormat);
   return mDrawTarget;
 }
 bool
 TextureClientD3D11::AllocateForSurface(gfx::IntSize aSize, TextureAllocationFlags aFlags)
 {
   mSize = aSize;
   ID3D10Device* device = gfxWindowsPlatform::GetPlatform()->GetD3D10Device();
   CD3D10_TEXTURE2D_DESC newDesc(DXGI_FORMAT_B8G8R8A8_UNORM,
                                 aSize.width, aSize.height, 1, 1,
                                 D3D10_BIND_RENDER_TARGET | D3D10_BIND_SHADER_RESOURCE);
   newDesc.MiscFlags = D3D10_RESOURCE_MISC_SHARED_KEYEDMUTEX;
   HRESULT hr = device->CreateTexture2D(&newDesc, nullptr, byRef(mTexture));
   if (FAILED(hr)) {
     LOGD3D11("Error creating texture for client!");
     return false;
   }
   // Defer clearing to the next time we lock to avoid an extra (expensive) lock.
   mNeedsClear = aFlags & ALLOC_CLEAR_BUFFER;
   return true;
 }
 bool
 TextureClientD3D11::ToSurfaceDescriptor(SurfaceDescriptor& aOutDescriptor)
 {
   if (!IsAllocated()) {
     return false;
   }
   RefPtr<IDXGIResource> resource;
   mTexture->QueryInterface((IDXGIResource**)byRef(resource));
   HANDLE sharedHandle;
   HRESULT hr = resource->GetSharedHandle(&sharedHandle);
   if (FAILED(hr)) {
     LOGD3D11("Error getting shared handle for texture.");
     return false;
   }
   aOutDescriptor = SurfaceDescriptorD3D10((WindowsHandle)sharedHandle, mFormat, mSize);
   return true;
 }
 DXGITextureHostD3D11::DXGITextureHostD3D11(TextureFlags aFlags,
                                            const SurfaceDescriptorD3D10& aDescriptor)
   : TextureHost(aFlags)
   , mHandle(aDescriptor.handle())
   , mFormat(aDescriptor.format())
   , mIsLocked(false)
 {}
 ID3D11Device*
 DXGITextureHostD3D11::GetDevice()
 {
   return mCompositor ? mCompositor->GetDevice() : nullptr;
 }
 void
 DXGITextureHostD3D11::SetCompositor(Compositor* aCompositor)
 {
   mCompositor = static_cast<CompositorD3D11*>(aCompositor);
 }
 bool
 DXGITextureHostD3D11::Lock()
 {
   if (!GetDevice()) {
     NS_WARNING("trying to lock a TextureHost without a D3D device");
     return false;
   }
   if (!mTextureSource) {
     RefPtr<ID3D11Texture2D> tex;
     HRESULT hr = GetDevice()->OpenSharedResource((HANDLE)mHandle,
                                                  __uuidof(ID3D11Texture2D),
                                                  (void**)(ID3D11Texture2D**)byRef(tex));
     if (FAILED(hr)) {
       NS_WARNING("Failed to open shared texture");
       return false;
     }
     mTextureSource = new DataTextureSourceD3D11(mFormat, mCompositor, tex);
     D3D11_TEXTURE2D_DESC desc;
     tex->GetDesc(&desc);
     mSize = IntSize(desc.Width, desc.Height);
   }
   LockD3DTexture(mTextureSource->GetD3D11Texture());
   mIsLocked = true;
   return true;
 }
 void
 DXGITextureHostD3D11::Unlock()
 {
   MOZ_ASSERT(mIsLocked);
   UnlockD3DTexture(mTextureSource->GetD3D11Texture());
   mIsLocked = false;
 }
 NewTextureSource*
 DXGITextureHostD3D11::GetTextureSources()
 {
   return mTextureSource.get();
 }
 bool
 DataTextureSourceD3D11::Update(DataSourceSurface* aSurface,
                                nsIntRegion* aDestRegion,
                                IntPoint* aSrcOffset)
 {
   // Right now we only support full surface update. If aDestRegion is provided,
   // It will be ignored. Incremental update with a source offset is only used
   // on Mac so it is not clear that we ever will need to support it for D3D.
   MOZ_ASSERT(!aSrcOffset);
   MOZ_ASSERT(aSurface);
   if (!mCompositor || !mCompositor->GetDevice()) {
     return false;
   }
   uint32_t bpp = BytesPerPixel(aSurface->GetFormat());
   DXGI_FORMAT dxgiFormat = SurfaceFormatToDXGIFormat(aSurface->GetFormat());
   mSize = aSurface->GetSize();
   mFormat = aSurface->GetFormat();
   CD3D11_TEXTURE2D_DESC desc(dxgiFormat, mSize.width, mSize.height,
 , 1, D3D11_BIND_SHADER_RESOURCE,
                              D3D11_USAGE_IMMUTABLE);
   int32_t maxSize = mCompositor->GetMaxTextureSize();
   if ((mSize.width <= maxSize && mSize.height <= maxSize) ||
       (mFlags & TEXTURE_DISALLOW_BIGIMAGE)) {
     D3D11_SUBRESOURCE_DATA initData;
     initData.pSysMem = aSurface->GetData();
     initData.SysMemPitch = aSurface->Stride();
     mCompositor->GetDevice()->CreateTexture2D(&desc, &initData, byRef(mTexture));
     mIsTiled = false;
     if (!mTexture) {
       Reset();
       return false;
     }
   } else {
     mIsTiled = true;
     uint32_t tileCount = GetRequiredTilesD3D11(mSize.width, maxSize) *
                          GetRequiredTilesD3D11(mSize.height, maxSize);
     mTileTextures.resize(tileCount);
     mTexture = nullptr;
     for (uint32_t i = 0; i < tileCount; i++) {
       IntRect tileRect = GetTileRect(i);
       desc.Width = tileRect.width;
       desc.Height = tileRect.height;
       D3D11_SUBRESOURCE_DATA initData;
       initData.pSysMem = aSurface->GetData() +
                          tileRect.y * aSurface->Stride() +
                          tileRect.x * bpp;
       initData.SysMemPitch = aSurface->Stride();
       mCompositor->GetDevice()->CreateTexture2D(&desc, &initData, byRef(mTileTextures[i]));
       if (!mTileTextures[i]) {
         Reset();
         return false;
       }
     }
   }
   return true;
 }
 ID3D11Texture2D*
 DataTextureSourceD3D11::GetD3D11Texture() const
 {
   return mIterating ? mTileTextures[mCurrentTile]
                     : mTexture;
 }
 void
 DataTextureSourceD3D11::Reset()
 {
   mTexture = nullptr;
   mTileTextures.resize(0);
   mIsTiled = false;
   mSize.width = 0;
   mSize.height = 0;
 }
 IntRect
 DataTextureSourceD3D11::GetTileRect(uint32_t aIndex) const
 {
   return GetTileRectD3D11(aIndex, mSize, mCompositor->GetMaxTextureSize());
 }
 nsIntRect
 DataTextureSourceD3D11::GetTileRect()
 {
   IntRect rect = GetTileRect(mCurrentTile);
   return nsIntRect(rect.x, rect.y, rect.width, rect.height);
 }
 void
 DataTextureSourceD3D11::SetCompositor(Compositor* aCompositor)
 {
   CompositorD3D11* d3dCompositor = static_cast<CompositorD3D11*>(aCompositor);
   if (mCompositor && mCompositor != d3dCompositor) {
     Reset();
   }
   mCompositor = d3dCompositor;
 }
 CompositingRenderTargetD3D11::CompositingRenderTargetD3D11(ID3D11Texture2D* aTexture,
                                                            const gfx::IntPoint& aOrigin)
   : CompositingRenderTarget(aOrigin)
 {
   MOZ_ASSERT(aTexture);
   mTexture = aTexture;
   RefPtr<ID3D11Device> device;
   mTexture->GetDevice(byRef(device));
   HRESULT hr = device->CreateRenderTargetView(mTexture, nullptr, byRef(mRTView));
   if (FAILED(hr)) {
     LOGD3D11("Failed to create RenderTargetView.");
   }
 }
 IntSize
 CompositingRenderTargetD3D11::GetSize() const
 {
   return TextureSourceD3D11::GetSize();
 }
 }
 }

The Tor Browser / annotate

gfx/layers/d3d11/TextureD3D11.cpp@129ffea94266 (annotated)

gfx/layers/d3d11/TextureD3D11.cpp