The Tor Browser: gfx/layers/d3d9/LayerManagerD3D9.cpp@129ffea94266 (annotated)

gfx/layers/d3d9/LayerManagerD3D9.cpp@129ffea94266 (annotated)

gfx/layers/d3d9/LayerManagerD3D9.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 "LayerManagerD3D9.h"
 #include "ThebesLayerD3D9.h"
 #include "ContainerLayerD3D9.h"
 #include "ImageLayerD3D9.h"
 #include "ColorLayerD3D9.h"
 #include "CanvasLayerD3D9.h"
 #include "ReadbackLayerD3D9.h"
 #include "gfxWindowsPlatform.h"
 #include "nsIGfxInfo.h"
 #include "nsServiceManagerUtils.h"
 #include "gfxFailure.h"
 #include "gfxPrefs.h"
 #include "gfxCrashReporterUtils.h"
 namespace mozilla {
 namespace layers {
 LayerManagerD3D9::LayerManagerD3D9(nsIWidget *aWidget)
   : mWidget(aWidget)
   , mDeviceResetCount(0)
 {
   mCurrentCallbackInfo.Callback = nullptr;
   mCurrentCallbackInfo.CallbackData = nullptr;
 }
 LayerManagerD3D9::~LayerManagerD3D9()
 {
   Destroy();
 }
 bool
 LayerManagerD3D9::Initialize(bool force)
 {
   ScopedGfxFeatureReporter reporter("D3D9 Layers", force);
   /* XXX: this preference and blacklist code should move out of the layer manager */
   bool forceAccelerate = gfxPrefs::LayersAccelerationForceEnabled();
   nsCOMPtr<nsIGfxInfo> gfxInfo = do_GetService("@mozilla.org/gfx/info;1");
   if (gfxInfo) {
     int32_t status;
     if (NS_SUCCEEDED(gfxInfo->GetFeatureStatus(nsIGfxInfo::FEATURE_DIRECT3D_9_LAYERS, &status))) {
       if (status != nsIGfxInfo::FEATURE_NO_INFO && !forceAccelerate)
       {
         NS_WARNING("Direct3D 9-accelerated layers are not supported on this system.");
         return false;
       }
     }
   }
   mDeviceManager = gfxWindowsPlatform::GetPlatform()->GetD3D9DeviceManager();
   if (!mDeviceManager) {
     return false;
   }
   mSwapChain = mDeviceManager->
     CreateSwapChain((HWND)mWidget->GetNativeData(NS_NATIVE_WINDOW));
   if (!mSwapChain) {
     return false;
   }
   reporter.SetSuccessful();
   return true;
 }
 void
 LayerManagerD3D9::SetClippingRegion(const nsIntRegion &aClippingRegion)
 {
   mClippingRegion = aClippingRegion;
 }
 void
 LayerManagerD3D9::Destroy()
 {
   if (!IsDestroyed()) {
     if (mRoot) {
       static_cast<LayerD3D9*>(mRoot->ImplData())->LayerManagerDestroyed();
     }
     /* Important to release this first since it also holds a reference to the
      * device manager
      */
     mSwapChain = nullptr;
     mDeviceManager = nullptr;
   }
   LayerManager::Destroy();
 }
 void
 LayerManagerD3D9::BeginTransaction()
 {
   mInTransaction = true;
 }
 void
 LayerManagerD3D9::BeginTransactionWithTarget(gfxContext *aTarget)
 {
   mInTransaction = true;
   mTarget = aTarget;
 }
 void
 LayerManagerD3D9::EndConstruction()
 {
 }
 bool
 LayerManagerD3D9::EndEmptyTransaction(EndTransactionFlags aFlags)
 {
   mInTransaction = false;
   // If the device reset count from our last EndTransaction doesn't match
   // the current device reset count, the device must have been reset one or
   // more times since our last transaction. In that case, an empty transaction
   // is not possible, because layers may need to be rerendered.
   if (!mRoot || mDeviceResetCount != mDeviceManager->GetDeviceResetCount())
     return false;
   EndTransaction(nullptr, nullptr, aFlags);
   return true;
 }
 void
 LayerManagerD3D9::EndTransaction(DrawThebesLayerCallback aCallback,
                                  void* aCallbackData,
                                  EndTransactionFlags aFlags)
 {
   mInTransaction = false;
   mDeviceResetCount = mDeviceManager->GetDeviceResetCount();
   if (mRoot && !(aFlags & END_NO_IMMEDIATE_REDRAW)) {
     mCurrentCallbackInfo.Callback = aCallback;
     mCurrentCallbackInfo.CallbackData = aCallbackData;
     if (aFlags & END_NO_COMPOSITE) {
       // Apply pending tree updates before recomputing effective
       // properties.
       mRoot->ApplyPendingUpdatesToSubtree();
     }
     // The results of our drawing always go directly into a pixel buffer,
     // so we don't need to pass any global transform here.
     mRoot->ComputeEffectiveTransforms(gfx::Matrix4x4());
     SetCompositingDisabled(aFlags & END_NO_COMPOSITE);
     Render();
     /* Clean this out for sanity */
     mCurrentCallbackInfo.Callback = nullptr;
     mCurrentCallbackInfo.CallbackData = nullptr;
   }
   // Clear mTarget, next transaction could have no target
   mTarget = nullptr;
 }
 void
 LayerManagerD3D9::SetRoot(Layer *aLayer)
 {
   mRoot = aLayer;
 }
 already_AddRefed<ThebesLayer>
 LayerManagerD3D9::CreateThebesLayer()
 {
   nsRefPtr<ThebesLayer> layer = new ThebesLayerD3D9(this);
   return layer.forget();
 }
 already_AddRefed<ContainerLayer>
 LayerManagerD3D9::CreateContainerLayer()
 {
   nsRefPtr<ContainerLayer> layer = new ContainerLayerD3D9(this);
   return layer.forget();
 }
 already_AddRefed<ImageLayer>
 LayerManagerD3D9::CreateImageLayer()
 {
   nsRefPtr<ImageLayer> layer = new ImageLayerD3D9(this);
   return layer.forget();
 }
 already_AddRefed<ColorLayer>
 LayerManagerD3D9::CreateColorLayer()
 {
   nsRefPtr<ColorLayer> layer = new ColorLayerD3D9(this);
   return layer.forget();
 }
 already_AddRefed<CanvasLayer>
 LayerManagerD3D9::CreateCanvasLayer()
 {
   nsRefPtr<CanvasLayer> layer = new CanvasLayerD3D9(this);
   return layer.forget();
 }
 already_AddRefed<ReadbackLayer>
 LayerManagerD3D9::CreateReadbackLayer()
 {
   nsRefPtr<ReadbackLayer> layer = new ReadbackLayerD3D9(this);
   return layer.forget();
 }
 void
 LayerManagerD3D9::ReportFailure(const nsACString &aMsg, HRESULT aCode)
 {
   // We could choose to abort here when hr == E_OUTOFMEMORY.
   nsCString msg;
   msg.Append(aMsg);
   msg.AppendLiteral(" Error code: ");
   msg.AppendInt(uint32_t(aCode));
   NS_WARNING(msg.BeginReading());
   gfx::LogFailure(msg);
 }
 void
 LayerManagerD3D9::Render()
 {
   if (mSwapChain->PrepareForRendering() != DeviceOK) {
     return;
   }
   deviceManager()->SetupRenderState();
   SetupPipeline();
   if (CompositingDisabled()) {
     static_cast<LayerD3D9*>(mRoot->ImplData())->RenderLayer();
     return;
   }
   nsIntRect rect;
   mWidget->GetClientBounds(rect);
   device()->Clear(0, nullptr, D3DCLEAR_TARGET, 0x00000000, 0, 0);
   device()->BeginScene();
   const nsIntRect *clipRect = mRoot->GetClipRect();
   RECT r;
   if (clipRect) {
     r.left = (LONG)clipRect->x;
     r.top = (LONG)clipRect->y;
     r.right = (LONG)(clipRect->x + clipRect->width);
     r.bottom = (LONG)(clipRect->y + clipRect->height);
   } else {
     r.left = r.top = 0;
     r.right = rect.width;
     r.bottom = rect.height;
   }
   device()->SetScissorRect(&r);
   static_cast<LayerD3D9*>(mRoot->ImplData())->RenderLayer();
   if (!mRegionToClear.IsEmpty()) {
     D3DRECT* rects = new D3DRECT[mRegionToClear.GetNumRects()];
     nsIntRegionRectIterator iter(mRegionToClear);
     const nsIntRect *r;
     size_t i = 0;
     while ((r = iter.Next())) {
       rects[i].x1 = r->x;
       rects[i].y1 = r->y;
       rects[i].x2 = r->x + r->width;
       rects[i].y2 = r->y + r->height;
       i++;
     }
     device()->Clear(i, rects, D3DCLEAR_TARGET,
 x00000000, 0, 0);
     delete [] rects;
   }
   device()->EndScene();
   if (!mTarget) {
     const nsIntRect *r;
     for (nsIntRegionRectIterator iter(mClippingRegion);
          (r = iter.Next()) != nullptr;) {
       mSwapChain->Present(*r);
     }
     RecordFrame();
     PostPresent();
   } else {
     PaintToTarget();
   }
 }
 void
 LayerManagerD3D9::SetupPipeline()
 {
   nsIntRect rect;
   mWidget->GetClientBounds(rect);
   gfx3DMatrix viewMatrix;
   /*
    * Matrix to transform to viewport space ( <-1.0, 1.0> topleft,
    * <1.0, -1.0> bottomright)
    */
   viewMatrix._11 = 2.0f / rect.width;
   viewMatrix._22 = -2.0f / rect.height;
   viewMatrix._33 = 0.0f;
   viewMatrix._41 = -1.0f;
   viewMatrix._42 = 1.0f;
   HRESULT hr = device()->SetVertexShaderConstantF(CBmProjection,
                                                   &viewMatrix._11, 4);
   if (FAILED(hr)) {
     NS_WARNING("Failed to set projection shader constant!");
   }
   hr = device()->SetVertexShaderConstantF(CBvTextureCoords,
                                           ShaderConstantRect(0, 0, 1.0f, 1.0f),
 );
   if (FAILED(hr)) {
     NS_WARNING("Failed to set texCoords shader constant!");
   }
   float offset[] = { 0, 0, 0, 0 };
   hr = device()->SetVertexShaderConstantF(CBvRenderTargetOffset, offset, 1);
   if (FAILED(hr)) {
     NS_WARNING("Failed to set RenderTargetOffset shader constant!");
   }
 }
 void
 LayerManagerD3D9::PaintToTarget()
 {
   nsRefPtr<IDirect3DSurface9> backBuff;
   nsRefPtr<IDirect3DSurface9> destSurf;
   device()->GetRenderTarget(0, getter_AddRefs(backBuff));
   D3DSURFACE_DESC desc;
   backBuff->GetDesc(&desc);
   device()->CreateOffscreenPlainSurface(desc.Width, desc.Height,
                                        D3DFMT_A8R8G8B8, D3DPOOL_SYSTEMMEM,
                                        getter_AddRefs(destSurf), nullptr);
   device()->GetRenderTargetData(backBuff, destSurf);
   D3DLOCKED_RECT rect;
   destSurf->LockRect(&rect, nullptr, D3DLOCK_READONLY);
   nsRefPtr<gfxImageSurface> imageSurface =
     new gfxImageSurface((unsigned char*)rect.pBits,
                         gfxIntSize(desc.Width, desc.Height),
                         rect.Pitch,
                         gfxImageFormat::ARGB32);
   mTarget->SetSource(imageSurface);
   mTarget->SetOperator(gfxContext::OPERATOR_OVER);
   mTarget->Paint();
   destSurf->UnlockRect();
 }
 LayerD3D9::LayerD3D9(LayerManagerD3D9 *aManager)
   : mD3DManager(aManager)
 {
 }
 } /* namespace layers */
 } /* namespace mozilla */

The Tor Browser / annotate

gfx/layers/d3d9/LayerManagerD3D9.cpp@129ffea94266 (annotated)

gfx/layers/d3d9/LayerManagerD3D9.cpp