Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-11-25 22:01:30 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[Bug 774505] Don't include Layers.h everywhere r=cjones

Browse Source
This commit is contained in:
David Zbarsky 2012-07-18 12:31:40 -04:00
parent 77c3bf67cc
commit 9a61d96c70
50 changed files with 181 additions and 158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
content/base/src/nsFrameLoader.h
View File

@ -19,9 +19,9 @@
#include "nsIURI.h" #include "nsIURI.h"
#include "nsAutoPtr.h" #include "nsAutoPtr.h"
#include "nsFrameMessageManager.h" #include "nsFrameMessageManager.h"
#include "Layers.h"
#include "mozilla/dom/Element.h" #include "mozilla/dom/Element.h"
#include "mozilla/Attributes.h" #include "mozilla/Attributes.h"
#include "Layers.h"
class nsIURI; class nsIURI;
class nsSubDocumentFrame; class nsSubDocumentFrame;

1
content/canvas/src/WebGLContext.h
View File

@ -25,7 +25,6 @@
#include "nsIObserver.h" #include "nsIObserver.h"
#include "GLContextProvider.h" #include "GLContextProvider.h"
#include "Layers.h"
#include "mozilla/LinkedList.h" #include "mozilla/LinkedList.h"
#include "mozilla/CheckedInt.h" #include "mozilla/CheckedInt.h"

5
content/media/nsBuiltinDecoder.h
View File

@ -196,9 +196,12 @@ destroying the nsBuiltinDecoder object.
#include "nsMediaDecoder.h" #include "nsMediaDecoder.h"
#include "nsHTMLMediaElement.h" #include "nsHTMLMediaElement.h"
#include "mozilla/ReentrantMonitor.h" #include "mozilla/ReentrantMonitor.h"
#include "ImageLayers.h"
class nsAudioStream; class nsAudioStream;
typedef mozilla::layers::Image Image;
typedef mozilla::layers::ImageContainer ImageContainer;
static inline bool IsCurrentThread(nsIThread* aThread) { static inline bool IsCurrentThread(nsIThread* aThread) {
return NS_GetCurrentThread() == aThread; return NS_GetCurrentThread() == aThread;
} }

1
content/media/nsBuiltinDecoderReader.h
View File

@ -7,7 +7,6 @@
#define nsBuiltinDecoderReader_h_ #define nsBuiltinDecoderReader_h_
#include <nsDeque.h> #include <nsDeque.h>
#include "ImageLayers.h"
#include "nsSize.h" #include "nsSize.h"
#include "mozilla/ReentrantMonitor.h" #include "mozilla/ReentrantMonitor.h"
#include "MediaStreamGraph.h" #include "MediaStreamGraph.h"

4
content/media/nsBuiltinDecoderStateMachine.cpp
View File

@ -550,11 +550,11 @@ void nsBuiltinDecoderStateMachine::SendOutputStreamAudio(AudioData* aAudio,
aStream->mAudioFramesWritten += aAudio->mFrames - PRInt32(offset); aStream->mAudioFramesWritten += aAudio->mFrames - PRInt32(offset);
} }
static void WriteVideoToMediaStream(Image* aImage, static void WriteVideoToMediaStream(mozilla::layers::Image* aImage,
PRInt64 aDuration, const gfxIntSize& aIntrinsicSize, PRInt64 aDuration, const gfxIntSize& aIntrinsicSize,
VideoSegment* aOutput) VideoSegment* aOutput)
{ {
nsRefPtr<Image> image = aImage; nsRefPtr<mozilla::layers::Image> image = aImage;
aOutput->AppendFrame(image.forget(), aDuration, aIntrinsicSize); aOutput->AppendFrame(image.forget(), aDuration, aIntrinsicSize);
} }

5
content/media/nsMediaDecoder.h
View File

@ -6,7 +6,6 @@
#if !defined(nsMediaDecoder_h_) #if !defined(nsMediaDecoder_h_)
#define nsMediaDecoder_h_ #define nsMediaDecoder_h_
#include "ImageLayers.h"
#include "mozilla/ReentrantMonitor.h" #include "mozilla/ReentrantMonitor.h"
#include "VideoFrameContainer.h" #include "VideoFrameContainer.h"
#include "MediaStreamGraph.h" #include "MediaStreamGraph.h"
@ -38,8 +37,6 @@ static const PRUint32 FRAMEBUFFER_LENGTH_MAX = 16384;
class nsMediaDecoder : public nsIObserver class nsMediaDecoder : public nsIObserver
{ {
public: public:
typedef mozilla::layers::Image Image;
typedef mozilla::layers::ImageContainer ImageContainer;
typedef mozilla::MediaResource MediaResource; typedef mozilla::MediaResource MediaResource;
typedef mozilla::ReentrantMonitor ReentrantMonitor; typedef mozilla::ReentrantMonitor ReentrantMonitor;
typedef mozilla::SourceMediaStream SourceMediaStream; typedef mozilla::SourceMediaStream SourceMediaStream;
@ -368,7 +365,7 @@ public:
virtual PRInt64 AudioQueueMemoryInUse() = 0; virtual PRInt64 AudioQueueMemoryInUse() = 0;
VideoFrameContainer* GetVideoFrameContainer() { return mVideoFrameContainer; } VideoFrameContainer* GetVideoFrameContainer() { return mVideoFrameContainer; }
ImageContainer* GetImageContainer() mozilla::layers::ImageContainer* GetImageContainer()
{ {
return mVideoFrameContainer ? mVideoFrameContainer->GetImageContainer() : nsnull; return mVideoFrameContainer ? mVideoFrameContainer->GetImageContainer() : nsnull;
} }

1
dom/bluetooth/BluetoothManager.h
View File

@ -11,6 +11,7 @@
#include "nsDOMEventTargetHelper.h" #include "nsDOMEventTargetHelper.h"
#include "nsIDOMBluetoothManager.h" #include "nsIDOMBluetoothManager.h"
#include "mozilla/Observer.h" #include "mozilla/Observer.h"
#include "nsIEventTarget.h"
BEGIN_BLUETOOTH_NAMESPACE BEGIN_BLUETOOTH_NAMESPACE

1
dom/file/FileHelper.h
View File

@ -10,6 +10,7 @@
#include "FileCommon.h" #include "FileCommon.h"
#include "nsIRequestObserver.h" #include "nsIRequestObserver.h"
#include "nsThreadUtils.h"
class nsIFileStorage; class nsIFileStorage;

2
dom/ipc/PBrowser.ipdl
View File

@ -20,7 +20,7 @@ include "IPC/nsGUIEventIPC.h";
using IPC::URI; using IPC::URI;
using gfxMatrix; using gfxMatrix;
using mozilla::LayersBackend; using mozilla::layers::LayersBackend;
using mozilla::WindowsHandle; using mozilla::WindowsHandle;
using nscolor; using nscolor;
using nsCompositionEvent; using nsCompositionEvent;

2
dom/ipc/TabChild.cpp
View File

@ -1030,7 +1030,7 @@ TabChild::InitWidget(const nsIntSize& size)
nsnull // nsDeviceContext nsnull // nsDeviceContext
); );
LayerManager::LayersBackend be; LayersBackend be;
uint64_t id; uint64_t id;
int32_t maxTextureSize; int32_t maxTextureSize;
RenderFrameChild* remoteFrame = RenderFrameChild* remoteFrame =

7
gfx/layers/ImageLayers.h
View File

@ -16,6 +16,7 @@
#include "mozilla/mozalloc.h" #include "mozilla/mozalloc.h"
#include "mozilla/Mutex.h" #include "mozilla/Mutex.h"
#include "gfxPlatform.h" #include "gfxPlatform.h"
#include "LayersBackend.h"
#ifdef XP_MACOSX #ifdef XP_MACOSX
#include "nsIOSurface.h" #include "nsIOSurface.h"
@ -133,9 +134,9 @@ public:
virtual already_AddRefed<gfxASurface> GetAsSurface() = 0; virtual already_AddRefed<gfxASurface> GetAsSurface() = 0;
virtual gfxIntSize GetSize() = 0; virtual gfxIntSize GetSize() = 0;
ImageBackendData* GetBackendData(LayerManager::LayersBackend aBackend) ImageBackendData* GetBackendData(LayersBackend aBackend)
{ return mBackendData[aBackend]; } { return mBackendData[aBackend]; }
void SetBackendData(LayerManager::LayersBackend aBackend, ImageBackendData* aData) void SetBackendData(LayersBackend aBackend, ImageBackendData* aData)
{ mBackendData[aBackend] = aData; } { mBackendData[aBackend] = aData; }
protected: protected:
@ -144,7 +145,7 @@ protected:
mFormat(aFormat) mFormat(aFormat)
{} {}
nsAutoPtr<ImageBackendData> mBackendData[LayerManager::LAYERS_LAST]; nsAutoPtr<ImageBackendData> mBackendData[mozilla::layers::LAYERS_LAST];
void* mImplData; void* mImplData;
Format mFormat; Format mFormat;

1
gfx/layers/LayerSorter.cpp
View File

@ -7,6 +7,7 @@
#include "DirectedGraph.h" #include "DirectedGraph.h"
#include "limits.h" #include "limits.h"
#include "gfxLineSegment.h" #include "gfxLineSegment.h"
#include "Layers.h"
namespace mozilla { namespace mozilla {
namespace layers { namespace layers {

4
gfx/layers/LayerSorter.h
View File

@ -6,11 +6,13 @@
#ifndef GFX_LAYERSORTER_H #ifndef GFX_LAYERSORTER_H
#define GFX_LAYERSORTER_H #define GFX_LAYERSORTER_H
#include "Layers.h" #include "nsTArray.h"
namespace mozilla { namespace mozilla {
namespace layers { namespace layers {
class Layer;
void SortLayersBy3DZOrder(nsTArray<Layer*>& aLayers); void SortLayersBy3DZOrder(nsTArray<Layer*>& aLayers);
} }

13
gfx/layers/Layers.h
View File

@ -18,7 +18,7 @@
#include "gfxPattern.h" #include "gfxPattern.h"
#include "nsTArray.h" #include "nsTArray.h"
#include "nsThreadUtils.h" #include "nsThreadUtils.h"
#include "LayersBackend.h"
#include "mozilla/gfx/2D.h" #include "mozilla/gfx/2D.h"
#include "mozilla/TimeStamp.h" #include "mozilla/TimeStamp.h"
@ -200,15 +200,6 @@ class THEBES_API LayerManager {
NS_INLINE_DECL_REFCOUNTING(LayerManager) NS_INLINE_DECL_REFCOUNTING(LayerManager)
public: public:
enum LayersBackend {
LAYERS_NONE = 0,
LAYERS_BASIC,
LAYERS_OPENGL,
LAYERS_D3D9,
LAYERS_D3D10,
LAYERS_LAST
};
LayerManager() : mDestroyed(false), mSnapEffectiveTransforms(true), mId(0) LayerManager() : mDestroyed(false), mSnapEffectiveTransforms(true), mId(0)
{ {
InitLog(); InitLog();
@ -508,7 +499,7 @@ public:
static bool IsLogEnabled(); static bool IsLogEnabled();
static PRLogModuleInfo* GetLog() { return sLog; } static PRLogModuleInfo* GetLog() { return sLog; }
bool IsCompositingCheap(LayerManager::LayersBackend aBackend) bool IsCompositingCheap(LayersBackend aBackend)
{ return LAYERS_BASIC != aBackend; } { return LAYERS_BASIC != aBackend; }
virtual bool IsCompositingCheap() { return true; } virtual bool IsCompositingCheap() { return true; }

22
gfx/layers/LayersBackend.h Normal file
View File

@ -0,0 +1,22 @@
/* -*- Mode: C++; tab-width: 2; 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/. */
#ifndef GFX_LAYERSBACKEND_H
#define GFX_LAYERSBACKEND_H
namespace mozilla {
namespace layers {
enum LayersBackend {
LAYERS_NONE = 0,
LAYERS_BASIC,
LAYERS_OPENGL,
LAYERS_D3D9,
LAYERS_D3D10,
LAYERS_LAST
};
}
}
#endif /* GFX_LAYERSBACKEND_H */

1
gfx/layers/Makefile.in
View File

@ -33,6 +33,7 @@ EXPORTS = \
BasicImplData.h \ BasicImplData.h \
ImageLayers.h \ ImageLayers.h \
Layers.h \ Layers.h \
LayersBackend.h \
LayerManagerOGLShaders.h \ LayerManagerOGLShaders.h \
LayerManagerOGL.h \ LayerManagerOGL.h \
LayerManagerOGLProgram.h \ LayerManagerOGLProgram.h \

3
gfx/layers/basic/BasicCanvasLayer.cpp
View File

@ -10,6 +10,7 @@
#include "BasicLayersImpl.h" #include "BasicLayersImpl.h"
#include "nsXULAppAPI.h" #include "nsXULAppAPI.h"
#include "LayersBackend.h"
using namespace mozilla::gfx; using namespace mozilla::gfx;
@ -374,7 +375,7 @@ BasicShadowableCanvasLayer::Paint(gfxContext* aContext, Layer* aMaskLayer)
} }
if (mGLContext && if (mGLContext &&
BasicManager()->GetParentBackendType() == LayerManager::LAYERS_OPENGL) { BasicManager()->GetParentBackendType() == mozilla::layers::LAYERS_OPENGL) {
TextureImage::TextureShareType flags; TextureImage::TextureShareType flags;
// if process type is default, then it is single-process (non-e10s) // if process type is default, then it is single-process (non-e10s)
if (XRE_GetProcessType() == GeckoProcessType_Default) if (XRE_GetProcessType() == GeckoProcessType_Default)

2
gfx/layers/basic/BasicLayerManager.cpp
View File

@ -1133,7 +1133,7 @@ BasicShadowLayerManager::CreateThebesLayer()
{ {
NS_ASSERTION(InConstruction(), "Only allowed in construction phase"); NS_ASSERTION(InConstruction(), "Only allowed in construction phase");
#ifdef FORCE_BASICTILEDTHEBESLAYER #ifdef FORCE_BASICTILEDTHEBESLAYER
if (HasShadowManager() && GetParentBackendType() == LayerManager::LAYERS_OPENGL) { if (HasShadowManager() && GetParentBackendType() == LAYERS_OPENGL) {
// BasicTiledThebesLayer doesn't support main // BasicTiledThebesLayer doesn't support main
// thread compositing so only return this layer // thread compositing so only return this layer
// type if we have a shadow manager. // type if we have a shadow manager.

32
gfx/layers/d3d10/ImageLayerD3D10.cpp
View File

@ -14,7 +14,7 @@
namespace mozilla { namespace mozilla {
namespace layers { namespace layers {
static already_AddRefed<ID3D10Texture2D> static already_AddRefed<ID3D10Texture2D>
DataToTexture(ID3D10Device *aDevice, DataToTexture(ID3D10Device *aDevice,
unsigned char *data, unsigned char *data,
@ -22,13 +22,13 @@ DataToTexture(ID3D10Device *aDevice,
const gfxIntSize &aSize) const gfxIntSize &aSize)
{ {
D3D10_SUBRESOURCE_DATA srdata; D3D10_SUBRESOURCE_DATA srdata;
CD3D10_TEXTURE2D_DESC desc(DXGI_FORMAT_B8G8R8A8_UNORM, CD3D10_TEXTURE2D_DESC desc(DXGI_FORMAT_B8G8R8A8_UNORM,
aSize.width, aSize.width,
aSize.height, aSize.height,
1, 1); 1, 1);
desc.Usage = D3D10_USAGE_IMMUTABLE; desc.Usage = D3D10_USAGE_IMMUTABLE;
srdata.pSysMem = data; srdata.pSysMem = data;
srdata.SysMemPitch = stride; srdata.SysMemPitch = stride;
@ -99,14 +99,14 @@ ImageLayerD3D10::GetImageSRView(Image* aImage, bool& aHasAlpha, IDXGIKeyedMutex
if (aImage->GetFormat() == Image::REMOTE_IMAGE_BITMAP) { if (aImage->GetFormat() == Image::REMOTE_IMAGE_BITMAP) {
RemoteBitmapImage *remoteImage = RemoteBitmapImage *remoteImage =
static_cast<RemoteBitmapImage*>(aImage); static_cast<RemoteBitmapImage*>(aImage);
if (!aImage->GetBackendData(LayerManager::LAYERS_D3D10)) { if (!aImage->GetBackendData(mozilla::layers::LAYERS_D3D10)) {
nsAutoPtr<TextureD3D10BackendData> dat(new TextureD3D10BackendData()); nsAutoPtr<TextureD3D10BackendData> dat(new TextureD3D10BackendData());
dat->mTexture = DataToTexture(device(), remoteImage->mData, remoteImage->mStride, remoteImage->mSize); dat->mTexture = DataToTexture(device(), remoteImage->mData, remoteImage->mStride, remoteImage->mSize);
if (dat->mTexture) { if (dat->mTexture) {
device()->CreateShaderResourceView(dat->mTexture, NULL, getter_AddRefs(dat->mSRView)); device()->CreateShaderResourceView(dat->mTexture, NULL, getter_AddRefs(dat->mSRView));
aImage->SetBackendData(LayerManager::LAYERS_D3D10, dat.forget()); aImage->SetBackendData(mozilla::layers::LAYERS_D3D10, dat.forget());
} }
} }
@ -126,13 +126,13 @@ ImageLayerD3D10::GetImageSRView(Image* aImage, bool& aHasAlpha, IDXGIKeyedMutex
return nsnull; return nsnull;
} }
if (!aImage->GetBackendData(LayerManager::LAYERS_D3D10)) { if (!aImage->GetBackendData(mozilla::layers::LAYERS_D3D10)) {
nsAutoPtr<TextureD3D10BackendData> dat(new TextureD3D10BackendData()); nsAutoPtr<TextureD3D10BackendData> dat(new TextureD3D10BackendData());
dat->mTexture = SurfaceToTexture(device(), cairoImage->mSurface, cairoImage->mSize); dat->mTexture = SurfaceToTexture(device(), cairoImage->mSurface, cairoImage->mSize);
if (dat->mTexture) { if (dat->mTexture) {
device()->CreateShaderResourceView(dat->mTexture, NULL, getter_AddRefs(dat->mSRView)); device()->CreateShaderResourceView(dat->mTexture, NULL, getter_AddRefs(dat->mSRView));
aImage->SetBackendData(LayerManager::LAYERS_D3D10, dat.forget()); aImage->SetBackendData(mozilla::layers::LAYERS_D3D10, dat.forget());
} }
} }
@ -143,7 +143,7 @@ ImageLayerD3D10::GetImageSRView(Image* aImage, bool& aHasAlpha, IDXGIKeyedMutex
} }
TextureD3D10BackendData *data = TextureD3D10BackendData *data =
static_cast<TextureD3D10BackendData*>(aImage->GetBackendData(LayerManager::LAYERS_D3D10)); static_cast<TextureD3D10BackendData*>(aImage->GetBackendData(mozilla::layers::LAYERS_D3D10));
if (!data) { if (!data) {
return nsnull; return nsnull;
@ -201,7 +201,7 @@ ImageLayerD3D10::RenderLayer()
if (!srView) { if (!srView) {
return; return;
} }
PRUint8 shaderFlags = SHADER_PREMUL; PRUint8 shaderFlags = SHADER_PREMUL;
shaderFlags |= LoadMaskTexture(); shaderFlags |= LoadMaskTexture();
shaderFlags |= hasAlpha shaderFlags |= hasAlpha
@ -228,12 +228,12 @@ ImageLayerD3D10::RenderLayer()
return; return;
} }
if (!yuvImage->GetBackendData(LayerManager::LAYERS_D3D10)) { if (!yuvImage->GetBackendData(mozilla::layers::LAYERS_D3D10)) {
AllocateTexturesYCbCr(yuvImage); AllocateTexturesYCbCr(yuvImage);
} }
PlanarYCbCrD3D10BackendData *data = PlanarYCbCrD3D10BackendData *data =
static_cast<PlanarYCbCrD3D10BackendData*>(yuvImage->GetBackendData(LayerManager::LAYERS_D3D10)); static_cast<PlanarYCbCrD3D10BackendData*>(yuvImage->GetBackendData(mozilla::layers::LAYERS_D3D10));
if (!data) { if (!data) {
return; return;
@ -367,7 +367,7 @@ void ImageLayerD3D10::AllocateTexturesYCbCr(PlanarYCbCrImage *aImage)
device()->CreateShaderResourceView(backendData->mCbTexture, NULL, getter_AddRefs(backendData->mCbView)); device()->CreateShaderResourceView(backendData->mCbTexture, NULL, getter_AddRefs(backendData->mCbView));
device()->CreateShaderResourceView(backendData->mCrTexture, NULL, getter_AddRefs(backendData->mCrView)); device()->CreateShaderResourceView(backendData->mCrTexture, NULL, getter_AddRefs(backendData->mCrView));
aImage->SetBackendData(LayerManager::LAYERS_D3D10, backendData.forget()); aImage->SetBackendData(mozilla::layers::LAYERS_D3D10, backendData.forget());
} }
already_AddRefed<ID3D10ShaderResourceView> already_AddRefed<ID3D10ShaderResourceView>
@ -469,9 +469,9 @@ RemoteDXGITextureImage::GetAsSurface()
TextureD3D10BackendData* TextureD3D10BackendData*
RemoteDXGITextureImage::GetD3D10TextureBackendData(ID3D10Device *aDevice) RemoteDXGITextureImage::GetD3D10TextureBackendData(ID3D10Device *aDevice)
{ {
if (GetBackendData(LayerManager::LAYERS_D3D10)) { if (GetBackendData(mozilla::layers::LAYERS_D3D10)) {
TextureD3D10BackendData *data = TextureD3D10BackendData *data =
static_cast<TextureD3D10BackendData*>(GetBackendData(LayerManager::LAYERS_D3D10)); static_cast<TextureD3D10BackendData*>(GetBackendData(mozilla::layers::LAYERS_D3D10));
nsRefPtr<ID3D10Device> device; nsRefPtr<ID3D10Device> device;
data->mTexture->GetDevice(getter_AddRefs(device)); data->mTexture->GetDevice(getter_AddRefs(device));
@ -494,7 +494,7 @@ RemoteDXGITextureImage::GetD3D10TextureBackendData(ID3D10Device *aDevice)
aDevice->CreateShaderResourceView(texture, NULL, getter_AddRefs(data->mSRView)); aDevice->CreateShaderResourceView(texture, NULL, getter_AddRefs(data->mSRView));
SetBackendData(LayerManager::LAYERS_D3D10, data); SetBackendData(mozilla::layers::LAYERS_D3D10, data);
return data.forget(); return data.forget();
} }

2
gfx/layers/d3d10/LayerManagerD3D10.h
View File

@ -55,8 +55,6 @@ extern cairo_user_data_key_t gKeyD3D10Texture;
class THEBES_API LayerManagerD3D10 : public ShadowLayerManager, class THEBES_API LayerManagerD3D10 : public ShadowLayerManager,
public ShadowLayerForwarder { public ShadowLayerForwarder {
public: public:
typedef LayerManager::LayersBackend LayersBackend;
LayerManagerD3D10(nsIWidget *aWidget); LayerManagerD3D10(nsIWidget *aWidget);
virtual ~LayerManagerD3D10(); virtual ~LayerManagerD3D10();

22
gfx/layers/d3d9/ImageLayerD3D9.cpp
View File

@ -279,7 +279,7 @@ static void AllocateTexturesYCbCr(PlanarYCbCrImage *aImage,
backendData->mCrTexture->UnlockRect(0); backendData->mCrTexture->UnlockRect(0);
} }
aImage->SetBackendData(LayerManager::LAYERS_D3D9, backendData.forget()); aImage->SetBackendData(mozilla::layers::LAYERS_D3D9, backendData.forget());
} }
Layer* Layer*
@ -304,11 +304,11 @@ ImageLayerD3D9::GetTexture(Image *aImage, bool& aHasAlpha)
RemoteBitmapImage *remoteImage = RemoteBitmapImage *remoteImage =
static_cast<RemoteBitmapImage*>(aImage); static_cast<RemoteBitmapImage*>(aImage);
if (!aImage->GetBackendData(LayerManager::LAYERS_D3D9)) { if (!aImage->GetBackendData(mozilla::layers::LAYERS_D3D9)) {
nsAutoPtr<TextureD3D9BackendData> dat(new TextureD3D9BackendData()); nsAutoPtr<TextureD3D9BackendData> dat(new TextureD3D9BackendData());
dat->mTexture = DataToTexture(device(), remoteImage->mData, remoteImage->mStride, remoteImage->mSize, D3DFMT_A8R8G8B8); dat->mTexture = DataToTexture(device(), remoteImage->mData, remoteImage->mStride, remoteImage->mSize, D3DFMT_A8R8G8B8);
if (dat->mTexture) { if (dat->mTexture) {
aImage->SetBackendData(LayerManager::LAYERS_D3D9, dat.forget()); aImage->SetBackendData(mozilla::layers::LAYERS_D3D9, dat.forget());
} }
} }
@ -321,11 +321,11 @@ ImageLayerD3D9::GetTexture(Image *aImage, bool& aHasAlpha)
return nsnull; return nsnull;
} }
if (!aImage->GetBackendData(LayerManager::LAYERS_D3D9)) { if (!aImage->GetBackendData(mozilla::layers::LAYERS_D3D9)) {
nsAutoPtr<TextureD3D9BackendData> dat(new TextureD3D9BackendData()); nsAutoPtr<TextureD3D9BackendData> dat(new TextureD3D9BackendData());
dat->mTexture = SurfaceToTexture(device(), cairoImage->mSurface, cairoImage->mSize); dat->mTexture = SurfaceToTexture(device(), cairoImage->mSurface, cairoImage->mSize);
if (dat->mTexture) { if (dat->mTexture) {
aImage->SetBackendData(LayerManager::LAYERS_D3D9, dat.forget()); aImage->SetBackendData(mozilla::layers::LAYERS_D3D9, dat.forget());
} }
} }
@ -336,7 +336,7 @@ ImageLayerD3D9::GetTexture(Image *aImage, bool& aHasAlpha)
} }
TextureD3D9BackendData *data = TextureD3D9BackendData *data =
static_cast<TextureD3D9BackendData*>(aImage->GetBackendData(LayerManager::LAYERS_D3D9)); static_cast<TextureD3D9BackendData*>(aImage->GetBackendData(mozilla::layers::LAYERS_D3D9));
if (!data) { if (!data) {
return nsnull; return nsnull;
@ -416,12 +416,12 @@ ImageLayerD3D9::RenderLayer()
return; return;
} }
if (!yuvImage->GetBackendData(LayerManager::LAYERS_D3D9)) { if (!yuvImage->GetBackendData(mozilla::layers::LAYERS_D3D9)) {
AllocateTexturesYCbCr(yuvImage, device(), mD3DManager); AllocateTexturesYCbCr(yuvImage, device(), mD3DManager);
} }
PlanarYCbCrD3D9BackendData *data = PlanarYCbCrD3D9BackendData *data =
static_cast<PlanarYCbCrD3D9BackendData*>(yuvImage->GetBackendData(LayerManager::LAYERS_D3D9)); static_cast<PlanarYCbCrD3D9BackendData*>(yuvImage->GetBackendData(mozilla::layers::LAYERS_D3D9));
if (!data) { if (!data) {
return; return;
@ -616,12 +616,12 @@ ShadowImageLayerD3D9::RenderLayer()
return; return;
} }
if (!mYCbCrImage->GetBackendData(LayerManager::LAYERS_D3D9)) { if (!mYCbCrImage->GetBackendData(mozilla::layers::LAYERS_D3D9)) {
AllocateTexturesYCbCr(mYCbCrImage, device(), mD3DManager); AllocateTexturesYCbCr(mYCbCrImage, device(), mD3DManager);
} }
PlanarYCbCrD3D9BackendData *data = PlanarYCbCrD3D9BackendData *data =
static_cast<PlanarYCbCrD3D9BackendData*>(mYCbCrImage->GetBackendData(LayerManager::LAYERS_D3D9)); static_cast<PlanarYCbCrD3D9BackendData*>(mYCbCrImage->GetBackendData(mozilla::layers::LAYERS_D3D9));
if (!data) { if (!data) {
return; return;
@ -630,7 +630,7 @@ ShadowImageLayerD3D9::RenderLayer()
if (!mYCbCrImage->mBufferSize) { if (!mYCbCrImage->mBufferSize) {
return; return;
} }
SetShaderTransformAndOpacity(); SetShaderTransformAndOpacity();
device()->SetVertexShaderConstantF(CBvLayerQuad, device()->SetVertexShaderConstantF(CBvLayerQuad,

4
gfx/layers/ipc/CompositorParent.cpp
View File

@ -640,7 +640,7 @@ CompositorParent::AllocPLayers(const LayersBackend& aBackendHint,
*aBackend = aBackendHint; *aBackend = aBackendHint;
if (aBackendHint == LayerManager::LAYERS_OPENGL) { if (aBackendHint == mozilla::layers::LAYERS_OPENGL) {
nsRefPtr<LayerManagerOGL> layerManager; nsRefPtr<LayerManagerOGL> layerManager;
layerManager = layerManager =
new LayerManagerOGL(mWidget, mEGLSurfaceSize.width, mEGLSurfaceSize.height, mRenderToEGLSurface); new LayerManagerOGL(mWidget, mEGLSurfaceSize.width, mEGLSurfaceSize.height, mRenderToEGLSurface);
@ -662,7 +662,7 @@ CompositorParent::AllocPLayers(const LayersBackend& aBackendHint,
} }
*aMaxTextureSize = layerManager->GetMaxTextureSize(); *aMaxTextureSize = layerManager->GetMaxTextureSize();
return new ShadowLayersParent(slm, this, 0); return new ShadowLayersParent(slm, this, 0);
} else if (aBackendHint == LayerManager::LAYERS_BASIC) { } else if (aBackendHint == mozilla::layers::LAYERS_BASIC) {
nsRefPtr<LayerManager> layerManager = new BasicShadowLayerManager(mWidget); nsRefPtr<LayerManager> layerManager = new BasicShadowLayerManager(mWidget);
mWidget = NULL; mWidget = NULL;
mLayerManager = layerManager; mLayerManager = layerManager;

2
gfx/layers/ipc/PCompositor.ipdl
View File

@ -7,7 +7,7 @@
include protocol PLayers; include protocol PLayers;
using mozilla::LayersBackend; using mozilla::layers::LayersBackend;
using mozilla::null_t; using mozilla::null_t;
namespace mozilla { namespace mozilla {

3
gfx/layers/ipc/ShadowLayers.cpp
View File

@ -22,6 +22,7 @@
#include "RenderTrace.h" #include "RenderTrace.h"
#include "sampler.h" #include "sampler.h"
#include "nsXULAppAPI.h" #include "nsXULAppAPI.h"
#include "LayersBackend.h"
using namespace mozilla::ipc; using namespace mozilla::ipc;
@ -109,7 +110,7 @@ struct AutoTxnEnd {
ShadowLayerForwarder::ShadowLayerForwarder() ShadowLayerForwarder::ShadowLayerForwarder()
: mShadowManager(NULL) : mShadowManager(NULL)
, mMaxTextureSize(0) , mMaxTextureSize(0)
, mParentBackend(LayerManager::LAYERS_NONE) , mParentBackend(mozilla::layers::LAYERS_NONE)
, mIsFirstPaint(false) , mIsFirstPaint(false)
{ {
mTxn = new Transaction(); mTxn = new Transaction();

3
gfx/layers/ipc/ShadowLayers.h
View File

@ -11,7 +11,7 @@
#include "gfxASurface.h" #include "gfxASurface.h"
#include "ImageLayers.h" #include "ImageLayers.h"
#include "Layers.h" #include "LayersBackend.h"
#include "mozilla/ipc/SharedMemory.h" #include "mozilla/ipc/SharedMemory.h"
class gfxSharedImageSurface; class gfxSharedImageSurface;
@ -101,7 +101,6 @@ class ShadowLayerForwarder
public: public:
typedef gfxASurface::gfxContentType gfxContentType; typedef gfxASurface::gfxContentType gfxContentType;
typedef LayerManager::LayersBackend LayersBackend;
virtual ~ShadowLayerForwarder(); virtual ~ShadowLayerForwarder();

47
gfx/layers/opengl/ImageLayerOGL.cpp
View File

@ -12,6 +12,7 @@
#include "gfxUtils.h" #include "gfxUtils.h"
#include "yuv_convert.h" #include "yuv_convert.h"
#include "GLContextProvider.h" #include "GLContextProvider.h"
#include "LayersBackend.h"
#if defined(MOZ_WIDGET_GTK2) && !defined(MOZ_PLATFORM_MAEMO) #if defined(MOZ_WIDGET_GTK2) && !defined(MOZ_PLATFORM_MAEMO)
# include "GLXLibrary.h" # include "GLXLibrary.h"
# include "mozilla/X11Util.h" # include "mozilla/X11Util.h"
@ -172,7 +173,7 @@ AllocateTextureIOSurface(MacIOSurfaceImage *aIOImage, mozilla::gl::GLContext* aG
aGL->fBindTexture(LOCAL_GL_TEXTURE_RECTANGLE_ARB, 0); aGL->fBindTexture(LOCAL_GL_TEXTURE_RECTANGLE_ARB, 0);
aIOImage->SetBackendData(LayerManager::LAYERS_OPENGL, backendData.forget()); aIOImage->SetBackendData(LAYERS_OPENGL, backendData.forget());
} }
#endif #endif
@ -189,7 +190,7 @@ AllocateTextureIOSurface(GonkIOSurfaceImage *aIOImage, mozilla::gl::GLContext* a
new GonkIOSurfaceImageOGLBackendData); new GonkIOSurfaceImageOGLBackendData);
backendData->mTexture.Allocate(aGL); backendData->mTexture.Allocate(aGL);
aIOImage->SetBackendData(LayerManager::LAYERS_OPENGL, backendData.forget()); aIOImage->SetBackendData(LAYERS_OPENGL, backendData.forget());
} }
#endif #endif
@ -231,18 +232,18 @@ ImageLayerOGL::RenderLayer(int,
} }
PlanarYCbCrOGLBackendData *data = PlanarYCbCrOGLBackendData *data =
static_cast<PlanarYCbCrOGLBackendData*>(yuvImage->GetBackendData(LayerManager::LAYERS_OPENGL)); static_cast<PlanarYCbCrOGLBackendData*>(yuvImage->GetBackendData(LAYERS_OPENGL));
if (data && data->mTextures->GetGLContext() != gl()) { if (data && data->mTextures->GetGLContext() != gl()) {
// If these textures were allocated by another layer manager, // If these textures were allocated by another layer manager,
// clear them out and re-allocate below. // clear them out and re-allocate below.
data = nsnull; data = nsnull;
yuvImage->SetBackendData(LayerManager::LAYERS_OPENGL, nsnull); yuvImage->SetBackendData(LAYERS_OPENGL, nsnull);
} }
if (!data) { if (!data) {
AllocateTexturesYCbCr(yuvImage); AllocateTexturesYCbCr(yuvImage);
data = static_cast<PlanarYCbCrOGLBackendData*>(yuvImage->GetBackendData(LayerManager::LAYERS_OPENGL)); data = static_cast<PlanarYCbCrOGLBackendData*>(yuvImage->GetBackendData(LAYERS_OPENGL));
} }
if (!data || data->mTextures->GetGLContext() != gl()) { if (!data || data->mTextures->GetGLContext() != gl()) {
@ -294,18 +295,18 @@ ImageLayerOGL::RenderLayer(int,
"Image layer has alpha image"); "Image layer has alpha image");
CairoOGLBackendData *data = CairoOGLBackendData *data =
static_cast<CairoOGLBackendData*>(cairoImage->GetBackendData(LayerManager::LAYERS_OPENGL)); static_cast<CairoOGLBackendData*>(cairoImage->GetBackendData(LAYERS_OPENGL));
if (data && data->mTexture.GetGLContext() != gl()) { if (data && data->mTexture.GetGLContext() != gl()) {
// If this texture was allocated by another layer manager, clear // If this texture was allocated by another layer manager, clear
// it out and re-allocate below. // it out and re-allocate below.
data = nsnull; data = nsnull;
cairoImage->SetBackendData(LayerManager::LAYERS_OPENGL, nsnull); cairoImage->SetBackendData(LAYERS_OPENGL, nsnull);
} }
if (!data) { if (!data) {
AllocateTexturesCairo(cairoImage); AllocateTexturesCairo(cairoImage);
data = static_cast<CairoOGLBackendData*>(cairoImage->GetBackendData(LayerManager::LAYERS_OPENGL)); data = static_cast<CairoOGLBackendData*>(cairoImage->GetBackendData(LAYERS_OPENGL));
} }
if (!data || data->mTexture.GetGLContext() != gl()) { if (!data || data->mTexture.GetGLContext() != gl()) {
@ -380,19 +381,19 @@ ImageLayerOGL::RenderLayer(int,
gl()->fActiveTexture(LOCAL_GL_TEXTURE0); gl()->fActiveTexture(LOCAL_GL_TEXTURE0);
if (!ioImage->GetBackendData(LayerManager::LAYERS_OPENGL)) { if (!ioImage->GetBackendData(LAYERS_OPENGL)) {
AllocateTextureIOSurface(ioImage, gl()); AllocateTextureIOSurface(ioImage, gl());
} }
MacIOSurfaceImageOGLBackendData *data = MacIOSurfaceImageOGLBackendData *data =
static_cast<MacIOSurfaceImageOGLBackendData*>(ioImage->GetBackendData(LayerManager::LAYERS_OPENGL)); static_cast<MacIOSurfaceImageOGLBackendData*>(ioImage->GetBackendData(LAYERS_OPENGL));
gl()->fActiveTexture(LOCAL_GL_TEXTURE0); gl()->fActiveTexture(LOCAL_GL_TEXTURE0);
gl()->fBindTexture(LOCAL_GL_TEXTURE_RECTANGLE_ARB, data->mTexture.GetTextureID()); gl()->fBindTexture(LOCAL_GL_TEXTURE_RECTANGLE_ARB, data->mTexture.GetTextureID());
ShaderProgramOGL *program = ShaderProgramOGL *program =
mOGLManager->GetProgram(gl::RGBARectLayerProgramType, GetMaskLayer()); mOGLManager->GetProgram(gl::RGBARectLayerProgramType, GetMaskLayer());
program->Activate(); program->Activate();
if (program->GetTexCoordMultiplierUniformLocation() != -1) { if (program->GetTexCoordMultiplierUniformLocation() != -1) {
// 2DRect case, get the multiplier right for a sampler2DRect // 2DRect case, get the multiplier right for a sampler2DRect
@ -400,16 +401,16 @@ ImageLayerOGL::RenderLayer(int,
} else { } else {
NS_ASSERTION(0, "no rects?"); NS_ASSERTION(0, "no rects?");
} }
program->SetLayerQuadRect(nsIntRect(0, 0, program->SetLayerQuadRect(nsIntRect(0, 0,
ioImage->GetSize().width, ioImage->GetSize().width,
ioImage->GetSize().height)); ioImage->GetSize().height));
program->SetLayerTransform(GetEffectiveTransform()); program->SetLayerTransform(GetEffectiveTransform());
program->SetLayerOpacity(GetEffectiveOpacity()); program->SetLayerOpacity(GetEffectiveOpacity());
program->SetRenderOffset(aOffset); program->SetRenderOffset(aOffset);
program->SetTextureUnit(0); program->SetTextureUnit(0);
program->LoadMask(GetMaskLayer()); program->LoadMask(GetMaskLayer());
mOGLManager->BindAndDrawQuad(program); mOGLManager->BindAndDrawQuad(program);
gl()->fBindTexture(LOCAL_GL_TEXTURE_RECTANGLE_ARB, 0); gl()->fBindTexture(LOCAL_GL_TEXTURE_RECTANGLE_ARB, 0);
#endif #endif
@ -424,11 +425,11 @@ ImageLayerOGL::RenderLayer(int,
gl()->MakeCurrent(); gl()->MakeCurrent();
gl()->fActiveTexture(LOCAL_GL_TEXTURE0); gl()->fActiveTexture(LOCAL_GL_TEXTURE0);
if (!ioImage->GetBackendData(LayerManager::LAYERS_OPENGL)) { if (!ioImage->GetBackendData(LAYERS_OPENGL)) {
AllocateTextureIOSurface(ioImage, gl()); AllocateTextureIOSurface(ioImage, gl());
} }
GonkIOSurfaceImageOGLBackendData *data = GonkIOSurfaceImageOGLBackendData *data =
static_cast<GonkIOSurfaceImageOGLBackendData*>(ioImage->GetBackendData(LayerManager::LAYERS_OPENGL)); static_cast<GonkIOSurfaceImageOGLBackendData*>(ioImage->GetBackendData(LAYERS_OPENGL));
gl()->fActiveTexture(LOCAL_GL_TEXTURE0); gl()->fActiveTexture(LOCAL_GL_TEXTURE0);
gl()->BindExternalBuffer(data->mTexture.GetTextureID(), ioImage->GetNativeBuffer()); gl()->BindExternalBuffer(data->mTexture.GetTextureID(), ioImage->GetNativeBuffer());
@ -514,7 +515,7 @@ ImageLayerOGL::AllocateTexturesYCbCr(PlanarYCbCrImage *aImage)
PlanarYCbCrImage::Data &data = aImage->mData; PlanarYCbCrImage::Data &data = aImage->mData;
gl()->MakeCurrent(); gl()->MakeCurrent();
mTextureRecycleBin->GetTexture(TextureRecycleBin::TEXTURE_Y, data.mYSize, gl(), &backendData->mTextures[0]); mTextureRecycleBin->GetTexture(TextureRecycleBin::TEXTURE_Y, data.mYSize, gl(), &backendData->mTextures[0]);
SetClamping(gl(), backendData->mTextures[0].GetTextureID()); SetClamping(gl(), backendData->mTextures[0].GetTextureID());
@ -533,7 +534,7 @@ ImageLayerOGL::AllocateTexturesYCbCr(PlanarYCbCrImage *aImage)
backendData->mCbCrSize = aImage->mData.mCbCrSize; backendData->mCbCrSize = aImage->mData.mCbCrSize;
backendData->mTextureRecycleBin = mTextureRecycleBin; backendData->mTextureRecycleBin = mTextureRecycleBin;
aImage->SetBackendData(LayerManager::LAYERS_OPENGL, backendData.forget()); aImage->SetBackendData(LAYERS_OPENGL, backendData.forget());
} }
void void
@ -566,7 +567,7 @@ ImageLayerOGL::AllocateTexturesCairo(CairoImage *aImage)
backendData->mLayerProgram = gl::RGBXLayerProgramType; backendData->mLayerProgram = gl::RGBXLayerProgramType;
} }
aImage->SetBackendData(LayerManager::LAYERS_OPENGL, backendData.forget()); aImage->SetBackendData(LAYERS_OPENGL, backendData.forget());
return; return;
} }
#endif #endif
@ -575,7 +576,7 @@ ImageLayerOGL::AllocateTexturesCairo(CairoImage *aImage)
nsIntRect(0,0, aImage->mSize.width, aImage->mSize.height), nsIntRect(0,0, aImage->mSize.width, aImage->mSize.height),
tex, true); tex, true);
aImage->SetBackendData(LayerManager::LAYERS_OPENGL, backendData.forget()); aImage->SetBackendData(LAYERS_OPENGL, backendData.forget());
} }
/* /*
@ -620,7 +621,7 @@ ImageLayerOGL::LoadAsTexture(GLuint aTextureUnit, gfxIntSize* aSize)
} }
CairoOGLBackendData *data = static_cast<CairoOGLBackendData*>( CairoOGLBackendData *data = static_cast<CairoOGLBackendData*>(
cairoImage->GetBackendData(LayerManager::LAYERS_OPENGL)); cairoImage->GetBackendData(LAYERS_OPENGL));
if (!data) { if (!data) {
NS_ASSERTION(cairoImage->mSurface->GetContentType() == gfxASurface::CONTENT_ALPHA, NS_ASSERTION(cairoImage->mSurface->GetContentType() == gfxASurface::CONTENT_ALPHA,
@ -650,7 +651,7 @@ ImageLayerOGL::LoadAsTexture(GLuint aTextureUnit, gfxIntSize* aSize)
texID, true, nsIntPoint(0,0), false, texID, true, nsIntPoint(0,0), false,
aTextureUnit); aTextureUnit);
cairoImage->SetBackendData(LayerManager::LAYERS_OPENGL, data); cairoImage->SetBackendData(LAYERS_OPENGL, data);
gl()->MakeCurrent(); gl()->MakeCurrent();
gl()->fActiveTexture(aTextureUnit); gl()->fActiveTexture(aTextureUnit);

5
gfx/layers/opengl/LayerManagerOGLProgram.h
View File

@ -12,12 +12,13 @@
#include "nsString.h" #include "nsString.h"
#include "GLContext.h" #include "GLContext.h"
#include "Layers.h" #include "gfx3DMatrix.h"
namespace mozilla { namespace mozilla {
namespace layers { namespace layers {
class Layer;
// The kinds of mask layer a shader can support // The kinds of mask layer a shader can support
// We rely on the items in this enum being sequential // We rely on the items in this enum being sequential
enum MaskType { enum MaskType {

14
ipc/glue/IPCMessageUtils.h
View File

@ -25,7 +25,7 @@
#include "nsRect.h" #include "nsRect.h"
#include "nsRegion.h" #include "nsRegion.h"
#include "gfxASurface.h" #include "gfxASurface.h"
#include "Layers.h" #include "LayersBackend.h"
#ifdef _MSC_VER #ifdef _MSC_VER
#pragma warning( disable : 4800 ) #pragma warning( disable : 4800 )
@ -40,15 +40,13 @@
namespace base { struct FileDescriptor { }; } namespace base { struct FileDescriptor { }; }
#endif #endif
using mozilla::layers::LayerManager;
namespace mozilla { namespace mozilla {
typedef gfxASurface::gfxContentType gfxContentType; typedef gfxASurface::gfxContentType gfxContentType;
typedef gfxASurface::gfxImageFormat PixelFormat; typedef gfxASurface::gfxImageFormat PixelFormat;
typedef gfxASurface::gfxSurfaceType gfxSurfaceType; typedef gfxASurface::gfxSurfaceType gfxSurfaceType;
typedef gfxPattern::GraphicsFilter GraphicsFilterType; typedef gfxPattern::GraphicsFilter GraphicsFilterType;
typedef LayerManager::LayersBackend LayersBackend; typedef layers::LayersBackend LayersBackend;
// This is a cross-platform approximation to HANDLE, which we expect // This is a cross-platform approximation to HANDLE, which we expect
// to be typedef'd to void* or thereabouts. // to be typedef'd to void* or thereabouts.
@ -518,10 +516,10 @@ struct ParamTraits<mozilla::GraphicsFilterType>
{}; {};
template <> template <>
struct ParamTraits<mozilla::LayersBackend> struct ParamTraits<mozilla::layers::LayersBackend>
: public EnumSerializer<mozilla::LayersBackend, : public EnumSerializer<mozilla::layers::LayersBackend,
LayerManager::LAYERS_NONE, mozilla::layers::LAYERS_NONE,
LayerManager::LAYERS_LAST> mozilla::layers::LAYERS_LAST>
{}; {};
template <> template <>

4
layout/base/FrameLayerBuilder.h
View File

@ -20,6 +20,10 @@ class gfxContext;
class nsRootPresContext; class nsRootPresContext;
namespace mozilla { namespace mozilla {
namespace layers {
class ContainerLayer;
class ThebesLayer;
}
class FrameLayerBuilder; class FrameLayerBuilder;

1
layout/base/nsDisplayList.h
View File

@ -20,7 +20,6 @@
#include "nsISelection.h" #include "nsISelection.h"
#include "nsCaret.h" #include "nsCaret.h"
#include "plarena.h" #include "plarena.h"
#include "Layers.h"
#include "nsRegion.h" #include "nsRegion.h"
#include "FrameLayerBuilder.h" #include "FrameLayerBuilder.h"
#include "nsThemeConstants.h" #include "nsThemeConstants.h"

2
layout/ipc/PRenderFrame.ipdl
View File

@ -8,7 +8,7 @@
include protocol PBrowser; include protocol PBrowser;
include protocol PLayers; include protocol PLayers;
using mozilla::LayersBackend; using mozilla::layers::LayersBackend;
namespace mozilla { namespace mozilla {
namespace layout { namespace layout {

1
layout/ipc/RenderFrameChild.cpp
View File

@ -7,6 +7,7 @@
#include "RenderFrameChild.h" #include "RenderFrameChild.h"
#include "mozilla/layers/ShadowLayersChild.h" #include "mozilla/layers/ShadowLayersChild.h"
#include "LayersBackend.h"
using mozilla::layers::PLayersChild; using mozilla::layers::PLayersChild;
using mozilla::layers::ShadowLayersChild; using mozilla::layers::ShadowLayersChild;

9
layout/ipc/RenderFrameParent.cpp
View File

@ -21,6 +21,7 @@
#include "nsSubDocumentFrame.h" #include "nsSubDocumentFrame.h"
#include "nsViewportFrame.h" #include "nsViewportFrame.h"
#include "RenderFrameParent.h" #include "RenderFrameParent.h"
#include "LayersBackend.h"
typedef nsContentView::ViewConfig ViewConfig; typedef nsContentView::ViewConfig ViewConfig;
using namespace mozilla::layers; using namespace mozilla::layers;
@ -95,7 +96,7 @@ AssertInTopLevelChromeDoc(ContainerLayer* aContainer,
nsIFrame* aContainedFrame) nsIFrame* aContainedFrame)
{ {
NS_ASSERTION( NS_ASSERTION(
(aContainer->Manager()->GetBackendType() != LayerManager::LAYERS_BASIC) || (aContainer->Manager()->GetBackendType() != mozilla::layers::LAYERS_BASIC) ||
(aContainedFrame->GetNearestWidget() == (aContainedFrame->GetNearestWidget() ==
static_cast<BasicLayerManager*>(aContainer->Manager())->GetRetainerWidget()), static_cast<BasicLayerManager*>(aContainer->Manager())->GetRetainerWidget()),
"Expected frame to be in top-level chrome document"); "Expected frame to be in top-level chrome document");
@ -316,7 +317,7 @@ ClearContainer(ContainerLayer* aContainer)
static bool static bool
IsTempLayerManager(LayerManager* aManager) IsTempLayerManager(LayerManager* aManager)
{ {
return (LayerManager::LAYERS_BASIC == aManager->GetBackendType() && return (mozilla::layers::LAYERS_BASIC == aManager->GetBackendType() &&
!static_cast<BasicLayerManager*>(aManager)->IsRetained()); !static_cast<BasicLayerManager*>(aManager)->IsRetained());
} }
@ -453,7 +454,7 @@ GetFrom(nsFrameLoader* aFrameLoader)
} }
RenderFrameParent::RenderFrameParent(nsFrameLoader* aFrameLoader, RenderFrameParent::RenderFrameParent(nsFrameLoader* aFrameLoader,
LayerManager::LayersBackend* aBackendType, mozilla::layers::LayersBackend* aBackendType,
int* aMaxTextureSize, int* aMaxTextureSize,
uint64_t* aId) uint64_t* aId)
: mLayersId(0) : mLayersId(0)
@ -464,7 +465,7 @@ RenderFrameParent::RenderFrameParent(nsFrameLoader* aFrameLoader,
mContentViews[FrameMetrics::ROOT_SCROLL_ID] = mContentViews[FrameMetrics::ROOT_SCROLL_ID] =
new nsContentView(aFrameLoader, FrameMetrics::ROOT_SCROLL_ID); new nsContentView(aFrameLoader, FrameMetrics::ROOT_SCROLL_ID);
*aBackendType = LayerManager::LAYERS_NONE; *aBackendType = mozilla::layers::LAYERS_NONE;
*aMaxTextureSize = 0; *aMaxTextureSize = 0;
*aId = 0; *aId = 0;

4
layout/ipc/RenderFrameParent.h
View File

@ -13,7 +13,7 @@
#include <map> #include <map>
#include "nsDisplayList.h" #include "nsDisplayList.h"
#include "Layers.h" #include "LayersBackend.h"
class nsContentView; class nsContentView;
class nsFrameLoader; class nsFrameLoader;
@ -41,7 +41,7 @@ public:
typedef std::map<ViewID, nsRefPtr<nsContentView> > ViewMap; typedef std::map<ViewID, nsRefPtr<nsContentView> > ViewMap;
RenderFrameParent(nsFrameLoader* aFrameLoader, RenderFrameParent(nsFrameLoader* aFrameLoader,
LayerManager::LayersBackend* aBackendType, mozilla::layers::LayersBackend* aBackendType,
int* aMaxTextureSize, int* aMaxTextureSize,
uint64_t* aId); uint64_t* aId);
virtual ~RenderFrameParent(); virtual ~RenderFrameParent();

6
widget/android/nsWindow.cpp
View File

@ -989,7 +989,7 @@ nsWindow::DrawTo(gfxASurface *targetSurface, const nsIntRect &invalidRect)
event.region = invalidRect; event.region = invalidRect;
switch (GetLayerManager(nsnull)->GetBackendType()) { switch (GetLayerManager(nsnull)->GetBackendType()) {
case LayerManager::LAYERS_BASIC: { case mozilla::layers::LAYERS_BASIC: {
nsRefPtr<gfxContext> ctx = new gfxContext(targetSurface); nsRefPtr<gfxContext> ctx = new gfxContext(targetSurface);
@ -1013,7 +1013,7 @@ nsWindow::DrawTo(gfxASurface *targetSurface, const nsIntRect &invalidRect)
break; break;
} }
case LayerManager::LAYERS_OPENGL: { case mozilla::layers::LAYERS_OPENGL: {
static_cast<mozilla::layers::LayerManagerOGL*>(GetLayerManager(nsnull))-> static_cast<mozilla::layers::LayerManagerOGL*>(GetLayerManager(nsnull))->
SetClippingRegion(nsIntRegion(boundsRect)); SetClippingRegion(nsIntRegion(boundsRect));
@ -1114,7 +1114,7 @@ nsWindow::OnDraw(AndroidGeckoEvent *ae)
AndroidBridge::Bridge()->HideProgressDialogOnce(); AndroidBridge::Bridge()->HideProgressDialogOnce();
if (GetLayerManager(nsnull)->GetBackendType() == LayerManager::LAYERS_BASIC) { if (GetLayerManager(nsnull)->GetBackendType() == mozilla::layers::LAYERS_BASIC) {
if (sNativeWindow) { if (sNativeWindow) {
unsigned char *bits; unsigned char *bits;
int width, height, format, stride; int width, height, format, stride;

6
widget/android/nsWindow.h
View File

@ -140,9 +140,9 @@ public:
NS_IMETHOD OnIMESelectionChange(void); NS_IMETHOD OnIMESelectionChange(void);
virtual nsIMEUpdatePreference GetIMEUpdatePreference(); virtual nsIMEUpdatePreference GetIMEUpdatePreference();
LayerManager* GetLayerManager (PLayersChild* aShadowManager = nsnull, LayerManager* GetLayerManager (PLayersChild* aShadowManager = nsnull,
LayersBackend aBackendHint = LayerManager::LAYERS_NONE, LayersBackend aBackendHint = mozilla::layers::LAYERS_NONE,
LayerManagerPersistence aPersistence = LAYER_MANAGER_CURRENT, LayerManagerPersistence aPersistence = LAYER_MANAGER_CURRENT,
bool* aAllowRetaining = nsnull); bool* aAllowRetaining = nsnull);
NS_IMETHOD ReparentNativeWidget(nsIWidget* aNewParent); NS_IMETHOD ReparentNativeWidget(nsIWidget* aNewParent);

2
widget/cocoa/nsChildView.mm
View File

@ -2551,7 +2551,7 @@ NSEvent* gLastDragMouseDownEvent = nil;
#endif #endif
LayerManager *layerManager = mGeckoChild->GetLayerManager(nsnull); LayerManager *layerManager = mGeckoChild->GetLayerManager(nsnull);
if (layerManager->GetBackendType() == LayerManager::LAYERS_OPENGL) { if (layerManager->GetBackendType() == mozilla::layers::LAYERS_OPENGL) {
NSOpenGLContext *glContext; NSOpenGLContext *glContext;
LayerManagerOGL *manager = static_cast<LayerManagerOGL*>(layerManager); LayerManagerOGL *manager = static_cast<LayerManagerOGL*>(layerManager);

2
widget/cocoa/nsCocoaWindow.h
View File

@ -245,7 +245,7 @@ public:
NS_IMETHOD Invalidate(const nsIntRect &aRect); NS_IMETHOD Invalidate(const nsIntRect &aRect);
virtual nsresult ConfigureChildren(const nsTArray<Configuration>& aConfigurations); virtual nsresult ConfigureChildren(const nsTArray<Configuration>& aConfigurations);
virtual LayerManager* GetLayerManager(PLayersChild* aShadowManager = nsnull, virtual LayerManager* GetLayerManager(PLayersChild* aShadowManager = nsnull,
LayersBackend aBackendHint = LayerManager::LAYERS_NONE, LayersBackend aBackendHint = mozilla::layers::LAYERS_NONE,
LayerManagerPersistence aPersistence = LAYER_MANAGER_CURRENT, LayerManagerPersistence aPersistence = LAYER_MANAGER_CURRENT,
bool* aAllowRetaining = nsnull); bool* aAllowRetaining = nsnull);
NS_IMETHOD DispatchEvent(nsGUIEvent* event, nsEventStatus & aStatus) ; NS_IMETHOD DispatchEvent(nsGUIEvent* event, nsEventStatus & aStatus) ;

6
widget/gonk/nsWindow.cpp
View File

@ -204,12 +204,12 @@ nsWindow::DoDraw(void)
gWindowToRedraw->mDirtyRegion.SetEmpty(); gWindowToRedraw->mDirtyRegion.SetEmpty();
LayerManager* lm = gWindowToRedraw->GetLayerManager(); LayerManager* lm = gWindowToRedraw->GetLayerManager();
if (LayerManager::LAYERS_OPENGL == lm->GetBackendType()) { if (mozilla::layers::LAYERS_OPENGL == lm->GetBackendType()) {
LayerManagerOGL* oglm = static_cast<LayerManagerOGL*>(lm); LayerManagerOGL* oglm = static_cast<LayerManagerOGL*>(lm);
oglm->SetClippingRegion(event.region); oglm->SetClippingRegion(event.region);
oglm->SetWorldTransform(sRotationMatrix); oglm->SetWorldTransform(sRotationMatrix);
gWindowToRedraw->mEventCallback(&event); gWindowToRedraw->mEventCallback(&event);
} else if (LayerManager::LAYERS_BASIC == lm->GetBackendType()) { } else if (mozilla::layers::LAYERS_BASIC == lm->GetBackendType()) {
MOZ_ASSERT(sFramebufferOpen || sUsingOMTC); MOZ_ASSERT(sFramebufferOpen || sUsingOMTC);
nsRefPtr<gfxASurface> targetSurface; nsRefPtr<gfxASurface> targetSurface;
@ -585,7 +585,7 @@ PRUint32
nsWindow::GetGLFrameBufferFormat() nsWindow::GetGLFrameBufferFormat()
{ {
if (mLayerManager && if (mLayerManager &&
mLayerManager->GetBackendType() == LayerManager::LAYERS_OPENGL) { mLayerManager->GetBackendType() == mozilla::layers::LAYERS_OPENGL) {
// We directly map the hardware fb on Gonk. The hardware fb // We directly map the hardware fb on Gonk. The hardware fb
// has RGB format. // has RGB format.
return LOCAL_GL_RGB; return LOCAL_GL_RGB;

2
widget/gonk/nsWindow.h
View File

@ -83,7 +83,7 @@ public:
virtual float GetDPI(); virtual float GetDPI();
virtual mozilla::layers::LayerManager* virtual mozilla::layers::LayerManager*
GetLayerManager(PLayersChild* aShadowManager = nsnull, GetLayerManager(PLayersChild* aShadowManager = nsnull,
LayersBackend aBackendHint = LayerManager::LAYERS_NONE, LayersBackend aBackendHint = mozilla::layers::LAYERS_NONE,
LayerManagerPersistence aPersistence = LAYER_MANAGER_CURRENT, LayerManagerPersistence aPersistence = LAYER_MANAGER_CURRENT,
bool* aAllowRetaining = nsnull); bool* aAllowRetaining = nsnull);
gfxASurface* GetThebesSurface(); gfxASurface* GetThebesSurface();

6
widget/gtk2/nsWindow.cpp
View File

@ -610,7 +610,7 @@ nsWindow::Destroy(void)
/** Need to clean our LayerManager up while still alive */ /** Need to clean our LayerManager up while still alive */
if (mLayerManager) { if (mLayerManager) {
nsRefPtr<GLContext> gl = nsnull; nsRefPtr<GLContext> gl = nsnull;
if (mLayerManager->GetBackendType() == LayerManager::LAYERS_OPENGL) { if (mLayerManager->GetBackendType() == mozilla::layers::LAYERS_OPENGL) {
LayerManagerOGL *ogllm = static_cast<LayerManagerOGL*>(mLayerManager.get()); LayerManagerOGL *ogllm = static_cast<LayerManagerOGL*>(mLayerManager.get());
gl = ogllm->gl(); gl = ogllm->gl();
} }
@ -2140,7 +2140,7 @@ nsWindow::OnExposeEvent(cairo_t *cr)
return TRUE; return TRUE;
} else if (GetLayerManager()->GetBackendType() == LayerManager::LAYERS_OPENGL) { } else if (GetLayerManager()->GetBackendType() == mozilla::layers::LAYERS_OPENGL) {
LayerManagerOGL *manager = static_cast<LayerManagerOGL*>(GetLayerManager()); LayerManagerOGL *manager = static_cast<LayerManagerOGL*>(GetLayerManager());
manager->SetClippingRegion(event.region); manager->SetClippingRegion(event.region);
@ -6204,7 +6204,7 @@ void
nsWindow::ClearCachedResources() nsWindow::ClearCachedResources()
{ {
if (mLayerManager && if (mLayerManager &&
mLayerManager->GetBackendType() == LayerManager::LAYERS_BASIC) { mLayerManager->GetBackendType() == mozilla::layers::LAYERS_BASIC) {
static_cast<BasicLayerManager*> (mLayerManager.get())-> static_cast<BasicLayerManager*> (mLayerManager.get())->
ClearCachedResources(); ClearCachedResources();
} }

9
widget/nsIWidget.h
View File

@ -15,7 +15,6 @@
#include "nsStringGlue.h" #include "nsStringGlue.h"
#include "prthread.h" #include "prthread.h"
#include "Layers.h"
#include "nsEvent.h" #include "nsEvent.h"
#include "nsCOMPtr.h" #include "nsCOMPtr.h"
#include "nsITheme.h" #include "nsITheme.h"
@ -23,6 +22,7 @@
#include "nsWidgetInitData.h" #include "nsWidgetInitData.h"
#include "nsTArray.h" #include "nsTArray.h"
#include "nsXULAppAPI.h" #include "nsXULAppAPI.h"
#include "LayersBackend.h"
// forward declarations // forward declarations
class nsFontMetrics; class nsFontMetrics;
@ -41,6 +41,7 @@ namespace dom {
class TabChild; class TabChild;
} }
namespace layers { namespace layers {
class LayerManager;
class PLayersChild; class PLayersChild;
} }
} }
@ -363,7 +364,7 @@ class nsIWidget : public nsISupports {
public: public:
typedef mozilla::layers::LayerManager LayerManager; typedef mozilla::layers::LayerManager LayerManager;
typedef LayerManager::LayersBackend LayersBackend; typedef mozilla::layers::LayersBackend LayersBackend;
typedef mozilla::layers::PLayersChild PLayersChild; typedef mozilla::layers::PLayersChild PLayersChild;
typedef mozilla::widget::IMEState IMEState; typedef mozilla::widget::IMEState IMEState;
typedef mozilla::widget::InputContext InputContext; typedef mozilla::widget::InputContext InputContext;
@ -1040,14 +1041,14 @@ class nsIWidget : public nsISupports {
*/ */
inline LayerManager* GetLayerManager(bool* aAllowRetaining = nsnull) inline LayerManager* GetLayerManager(bool* aAllowRetaining = nsnull)
{ {
return GetLayerManager(nsnull, LayerManager::LAYERS_NONE, return GetLayerManager(nsnull, mozilla::layers::LAYERS_NONE,
LAYER_MANAGER_CURRENT, aAllowRetaining); LAYER_MANAGER_CURRENT, aAllowRetaining);
} }
inline LayerManager* GetLayerManager(LayerManagerPersistence aPersistence, inline LayerManager* GetLayerManager(LayerManagerPersistence aPersistence,
bool* aAllowRetaining = nsnull) bool* aAllowRetaining = nsnull)
{ {
return GetLayerManager(nsnull, LayerManager::LAYERS_NONE, return GetLayerManager(nsnull, mozilla::layers::LAYERS_NONE,
aPersistence, aAllowRetaining); aPersistence, aAllowRetaining);
} }

4
widget/qt/nsWindow.cpp
View File

@ -1040,7 +1040,7 @@ nsWindow::DoPaint(QPainter* aPainter, const QStyleOptionGraphicsItem* aOption, Q
startup->RemoveFakeLayout(); startup->RemoveFakeLayout();
} }
if (GetLayerManager(nsnull)->GetBackendType() == LayerManager::LAYERS_OPENGL) { if (GetLayerManager(nsnull)->GetBackendType() == mozilla::layers::LAYERS_OPENGL) {
aPainter->beginNativePainting(); aPainter->beginNativePainting();
nsPaintEvent event(true, NS_PAINT, this); nsPaintEvent event(true, NS_PAINT, this);
event.willSendDidPaint = true; event.willSendDidPaint = true;
@ -3308,7 +3308,7 @@ PRUint32
nsWindow::GetGLFrameBufferFormat() nsWindow::GetGLFrameBufferFormat()
{ {
if (mLayerManager && if (mLayerManager &&
mLayerManager->GetBackendType() == LayerManager::LAYERS_OPENGL) { mLayerManager->GetBackendType() == mozilla::layers::LAYERS_OPENGL) {
// On maemo the hardware fb has RGB format. // On maemo the hardware fb has RGB format.
#ifdef MOZ_PLATFORM_MAEMO #ifdef MOZ_PLATFORM_MAEMO
return LOCAL_GL_RGB; return LOCAL_GL_RGB;

28
widget/windows/nsWindow.cpp
View File

@ -1339,7 +1339,7 @@ NS_METHOD nsWindow::Move(PRInt32 aX, PRInt32 aY)
// region, some drivers or OSes may incorrectly copy into the clipped-out // region, some drivers or OSes may incorrectly copy into the clipped-out
// area. // area.
if (mWindowType == eWindowType_plugin && if (mWindowType == eWindowType_plugin &&
(!mLayerManager || mLayerManager->GetBackendType() == LayerManager::LAYERS_D3D9) && (!mLayerManager || mLayerManager->GetBackendType() == LAYERS_D3D9) &&
mClipRects && mClipRects &&
(mClipRectCount != 1 || !mClipRects[0].IsEqualInterior(nsIntRect(0, 0, mBounds.width, mBounds.height)))) { (mClipRectCount != 1 || !mClipRects[0].IsEqualInterior(nsIntRect(0, 0, mBounds.width, mBounds.height)))) {
flags |= SWP_NOCOPYBITS; flags |= SWP_NOCOPYBITS;
@ -3140,11 +3140,10 @@ nsWindow::GetLayerManager(PLayersChild* aShadowManager,
#ifdef MOZ_ENABLE_D3D10_LAYER #ifdef MOZ_ENABLE_D3D10_LAYER
if (mLayerManager) { if (mLayerManager) {
if (mLayerManager->GetBackendType() == if (mLayerManager->GetBackendType() == LAYERS_D3D10)
mozilla::layers::LayerManager::LAYERS_D3D10)
{ {
mozilla::layers::LayerManagerD3D10 *layerManagerD3D10 = LayerManagerD3D10 *layerManagerD3D10 =
static_cast<mozilla::layers::LayerManagerD3D10*>(mLayerManager.get()); static_cast<LayerManagerD3D10*>(mLayerManager.get());
if (layerManagerD3D10->device() != if (layerManagerD3D10->device() !=
gfxWindowsPlatform::GetPlatform()->GetD3D10Device()) gfxWindowsPlatform::GetPlatform()->GetD3D10Device())
{ {
@ -3160,8 +3159,7 @@ nsWindow::GetLayerManager(PLayersChild* aShadowManager,
if (!mLayerManager || if (!mLayerManager ||
(!sAllowD3D9 && aPersistence == LAYER_MANAGER_PERSISTENT && (!sAllowD3D9 && aPersistence == LAYER_MANAGER_PERSISTENT &&
mLayerManager->GetBackendType() == mLayerManager->GetBackendType() == LAYERS_BASIC)) {
mozilla::layers::LayerManager::LAYERS_BASIC)) {
// If D3D9 is not currently allowed but the permanent manager is required, // If D3D9 is not currently allowed but the permanent manager is required,
// -and- we're currently using basic layers, run through this check. // -and- we're currently using basic layers, run through this check.
LayerManagerPrefs prefs; LayerManagerPrefs prefs;
@ -3187,8 +3185,8 @@ nsWindow::GetLayerManager(PLayersChild* aShadowManager,
#ifdef MOZ_ENABLE_D3D10_LAYER #ifdef MOZ_ENABLE_D3D10_LAYER
if (!prefs.mPreferD3D9 && !prefs.mPreferOpenGL) { if (!prefs.mPreferD3D9 && !prefs.mPreferOpenGL) {
nsRefPtr<mozilla::layers::LayerManagerD3D10> layerManager = nsRefPtr<LayerManagerD3D10> layerManager =
new mozilla::layers::LayerManagerD3D10(this); new LayerManagerD3D10(this);
if (layerManager->Initialize(prefs.mForceAcceleration)) { if (layerManager->Initialize(prefs.mForceAcceleration)) {
mLayerManager = layerManager; mLayerManager = layerManager;
} }
@ -3196,8 +3194,8 @@ nsWindow::GetLayerManager(PLayersChild* aShadowManager,
#endif #endif
#ifdef MOZ_ENABLE_D3D9_LAYER #ifdef MOZ_ENABLE_D3D9_LAYER
if (!prefs.mPreferOpenGL && !mLayerManager && sAllowD3D9) { if (!prefs.mPreferOpenGL && !mLayerManager && sAllowD3D9) {
nsRefPtr<mozilla::layers::LayerManagerD3D9> layerManager = nsRefPtr<LayerManagerD3D9> layerManager =
new mozilla::layers::LayerManagerD3D9(this); new LayerManagerD3D9(this);
if (layerManager->Initialize(prefs.mForceAcceleration)) { if (layerManager->Initialize(prefs.mForceAcceleration)) {
mLayerManager = layerManager; mLayerManager = layerManager;
} }
@ -3212,8 +3210,8 @@ nsWindow::GetLayerManager(PLayersChild* aShadowManager,
} }
if (status == nsIGfxInfo::FEATURE_NO_INFO) { if (status == nsIGfxInfo::FEATURE_NO_INFO) {
nsRefPtr<mozilla::layers::LayerManagerOGL> layerManager = nsRefPtr<LayerManagerOGL> layerManager =
new mozilla::layers::LayerManagerOGL(this); new LayerManagerOGL(this);
if (layerManager->Initialize()) { if (layerManager->Initialize()) {
mLayerManager = layerManager; mLayerManager = layerManager;
} }
@ -6778,7 +6776,7 @@ nsWindow::ConfigureChildren(const nsTArray<Configuration>& aConfigurations)
if (gfxWindowsPlatform::GetPlatform()->GetRenderMode() == if (gfxWindowsPlatform::GetPlatform()->GetRenderMode() ==
gfxWindowsPlatform::RENDER_DIRECT2D || gfxWindowsPlatform::RENDER_DIRECT2D ||
GetLayerManager()->GetBackendType() != LayerManager::LAYERS_BASIC) { GetLayerManager()->GetBackendType() != LAYERS_BASIC) {
// XXX - Workaround for Bug 587508. This will invalidate the part of the // XXX - Workaround for Bug 587508. This will invalidate the part of the
// plugin window that might be touched by moving content somehow. The // plugin window that might be touched by moving content somehow. The
// underlying problem should be found and fixed! // underlying problem should be found and fixed!
@ -7751,7 +7749,7 @@ nsWindow::ClearCachedResources()
mD2DWindowSurface = nsnull; mD2DWindowSurface = nsnull;
#endif #endif
if (mLayerManager && if (mLayerManager &&
mLayerManager->GetBackendType() == LayerManager::LAYERS_BASIC) { mLayerManager->GetBackendType() == LAYERS_BASIC) {
static_cast<BasicLayerManager*>(mLayerManager.get())-> static_cast<BasicLayerManager*>(mLayerManager.get())->
ClearCachedResources(); ClearCachedResources();
} }

2
widget/windows/nsWindow.h
View File

@ -132,7 +132,7 @@ public:
NS_IMETHOD GetAttention(PRInt32 aCycleCount); NS_IMETHOD GetAttention(PRInt32 aCycleCount);
virtual bool HasPendingInputEvent(); virtual bool HasPendingInputEvent();
virtual LayerManager* GetLayerManager(PLayersChild* aShadowManager = nsnull, virtual LayerManager* GetLayerManager(PLayersChild* aShadowManager = nsnull,
LayersBackend aBackendHint = LayerManager::LAYERS_NONE, LayersBackend aBackendHint = mozilla::layers::LAYERS_NONE,
LayerManagerPersistence aPersistence = LAYER_MANAGER_CURRENT, LayerManagerPersistence aPersistence = LAYER_MANAGER_CURRENT,
bool* aAllowRetaining = nsnull); bool* aAllowRetaining = nsnull);
gfxASurface *GetThebesSurface(); gfxASurface *GetThebesSurface();

10
widget/windows/nsWindowGfx.cpp
View File

@ -70,7 +70,7 @@ using namespace mozilla::widget;
/************************************************************** /**************************************************************
* *
* SECTION: nsWindow statics * SECTION: nsWindow statics
* *
**************************************************************/ **************************************************************/
static nsAutoPtr<PRUint8> sSharedSurfaceData; static nsAutoPtr<PRUint8> sSharedSurfaceData;
@ -304,7 +304,7 @@ bool nsWindow::OnPaint(HDC aDC, PRUint32 aNestingLevel)
#endif // WIDGET_DEBUG_OUTPUT #endif // WIDGET_DEBUG_OUTPUT
switch (GetLayerManager()->GetBackendType()) { switch (GetLayerManager()->GetBackendType()) {
case LayerManager::LAYERS_BASIC: case LAYERS_BASIC:
{ {
nsRefPtr<gfxASurface> targetSurface; nsRefPtr<gfxASurface> targetSurface;
@ -535,13 +535,13 @@ bool nsWindow::OnPaint(HDC aDC, PRUint32 aNestingLevel)
} }
} }
break; break;
case LayerManager::LAYERS_OPENGL: case LAYERS_OPENGL:
static_cast<mozilla::layers::LayerManagerOGL*>(GetLayerManager())-> static_cast<mozilla::layers::LayerManagerOGL*>(GetLayerManager())->
SetClippingRegion(event.region); SetClippingRegion(event.region);
result = DispatchWindowEvent(&event, eventStatus); result = DispatchWindowEvent(&event, eventStatus);
break; break;
#ifdef MOZ_ENABLE_D3D9_LAYER #ifdef MOZ_ENABLE_D3D9_LAYER
case LayerManager::LAYERS_D3D9: case LAYERS_D3D9:
{ {
LayerManagerD3D9 *layerManagerD3D9 = LayerManagerD3D9 *layerManagerD3D9 =
static_cast<mozilla::layers::LayerManagerD3D9*>(GetLayerManager()); static_cast<mozilla::layers::LayerManagerD3D9*>(GetLayerManager());
@ -559,7 +559,7 @@ bool nsWindow::OnPaint(HDC aDC, PRUint32 aNestingLevel)
break; break;
#endif #endif
#ifdef MOZ_ENABLE_D3D10_LAYER #ifdef MOZ_ENABLE_D3D10_LAYER
case LayerManager::LAYERS_D3D10: case LAYERS_D3D10:
{ {
gfxWindowsPlatform::GetPlatform()->UpdateRenderMode(); gfxWindowsPlatform::GetPlatform()->UpdateRenderMode();
LayerManagerD3D10 *layerManagerD3D10 = static_cast<mozilla::layers::LayerManagerD3D10*>(GetLayerManager()); LayerManagerD3D10 *layerManagerD3D10 = static_cast<mozilla::layers::LayerManagerD3D10*>(GetLayerManager());

4
widget/xpwidgets/PuppetWidget.cpp
View File

@ -290,7 +290,7 @@ PuppetWidget::GetLayerManager(PLayersChild* aShadowManager,
// The backend hint is a temporary placeholder until Azure, when // The backend hint is a temporary placeholder until Azure, when
// all content-process layer managers will be BasicLayerManagers. // all content-process layer managers will be BasicLayerManagers.
#if defined(MOZ_ENABLE_D3D10_LAYER) #if defined(MOZ_ENABLE_D3D10_LAYER)
if (LayerManager::LAYERS_D3D10 == aBackendHint) { if (mozilla::layers::LAYERS_D3D10 == aBackendHint) {
nsRefPtr<LayerManagerD3D10> m = new LayerManagerD3D10(this); nsRefPtr<LayerManagerD3D10> m = new LayerManagerD3D10(this);
m->AsShadowForwarder()->SetShadowManager(aShadowManager); m->AsShadowForwarder()->SetShadowManager(aShadowManager);
if (m->Initialize()) { if (m->Initialize()) {
@ -498,7 +498,7 @@ PuppetWidget::DispatchPaintEvent()
nsCAutoString("PuppetWidget"), nsnull); nsCAutoString("PuppetWidget"), nsnull);
#endif #endif
if (LayerManager::LAYERS_D3D10 == mLayerManager->GetBackendType()) { if (mozilla::layers::LAYERS_D3D10 == mLayerManager->GetBackendType()) {
DispatchEvent(&event, status); DispatchEvent(&event, status);
} else { } else {
nsRefPtr<gfxContext> ctx = new gfxContext(mSurface); nsRefPtr<gfxContext> ctx = new gfxContext(mSurface);

3
widget/xpwidgets/PuppetWidget.h
View File

@ -21,6 +21,7 @@
#include "nsThreadUtils.h" #include "nsThreadUtils.h"
#include "nsWeakReference.h" #include "nsWeakReference.h"
#include "mozilla/Attributes.h" #include "mozilla/Attributes.h"
#include "LayersBackend.h"
class gfxASurface; class gfxASurface;
@ -135,7 +136,7 @@ public:
//NS_IMETHOD CaptureMouse(bool aCapture); //NS_IMETHOD CaptureMouse(bool aCapture);
virtual LayerManager* virtual LayerManager*
GetLayerManager(PLayersChild* aShadowManager = nsnull, GetLayerManager(PLayersChild* aShadowManager = nsnull,
LayersBackend aBackendHint = LayerManager::LAYERS_NONE, LayersBackend aBackendHint = mozilla::layers::LAYERS_NONE,
LayerManagerPersistence aPersistence = LAYER_MANAGER_CURRENT, LayerManagerPersistence aPersistence = LAYER_MANAGER_CURRENT,
bool* aAllowRetaining = nsnull); bool* aAllowRetaining = nsnull);
// virtual nsDeviceContext* GetDeviceContext(); // virtual nsDeviceContext* GetDeviceContext();

14
widget/xpwidgets/nsBaseWidget.cpp
View File

@ -145,7 +145,7 @@ void nsBaseWidget::DestroyCompositor()
nsBaseWidget::~nsBaseWidget() nsBaseWidget::~nsBaseWidget()
{ {
if (mLayerManager && if (mLayerManager &&
mLayerManager->GetBackendType() == LayerManager::LAYERS_BASIC) { mLayerManager->GetBackendType() == LAYERS_BASIC) {
static_cast<BasicLayerManager*>(mLayerManager.get())->ClearRetainerWidget(); static_cast<BasicLayerManager*>(mLayerManager.get())->ClearRetainerWidget();
} }
@ -737,7 +737,7 @@ nsBaseWidget::AutoLayerManagerSetup::AutoLayerManagerSetup(
BasicLayerManager* manager = BasicLayerManager* manager =
static_cast<BasicLayerManager*>(mWidget->GetLayerManager()); static_cast<BasicLayerManager*>(mWidget->GetLayerManager());
if (manager) { if (manager) {
NS_ASSERTION(manager->GetBackendType() == LayerManager::LAYERS_BASIC, NS_ASSERTION(manager->GetBackendType() == LAYERS_BASIC,
"AutoLayerManagerSetup instantiated for non-basic layer backend!"); "AutoLayerManagerSetup instantiated for non-basic layer backend!");
manager->SetDefaultTarget(aTarget, aDoubleBuffering); manager->SetDefaultTarget(aTarget, aDoubleBuffering);
} }
@ -748,7 +748,7 @@ nsBaseWidget::AutoLayerManagerSetup::~AutoLayerManagerSetup()
BasicLayerManager* manager = BasicLayerManager* manager =
static_cast<BasicLayerManager*>(mWidget->GetLayerManager()); static_cast<BasicLayerManager*>(mWidget->GetLayerManager());
if (manager) { if (manager) {
NS_ASSERTION(manager->GetBackendType() == LayerManager::LAYERS_BASIC, NS_ASSERTION(manager->GetBackendType() == LAYERS_BASIC,
"AutoLayerManagerSetup instantiated for non-basic layer backend!"); "AutoLayerManagerSetup instantiated for non-basic layer backend!");
manager->SetDefaultTarget(nsnull, BasicLayerManager::BUFFER_NONE); manager->SetDefaultTarget(nsnull, BasicLayerManager::BUFFER_NONE);
} }
@ -878,9 +878,9 @@ void nsBaseWidget::CreateCompositor()
mCompositorChild->Open(parentChannel, childMessageLoop, childSide); mCompositorChild->Open(parentChannel, childMessageLoop, childSide);
PRInt32 maxTextureSize; PRInt32 maxTextureSize;
PLayersChild* shadowManager; PLayersChild* shadowManager;
LayerManager::LayersBackend backendHint = mozilla::layers::LayersBackend backendHint =
mUseAcceleratedRendering ? LayerManager::LAYERS_OPENGL : LayerManager::LAYERS_BASIC; mUseAcceleratedRendering ? mozilla::layers::LAYERS_OPENGL : mozilla::layers::LAYERS_BASIC;
LayerManager::LayersBackend parentBackend; mozilla::layers::LayersBackend parentBackend;
shadowManager = mCompositorChild->SendPLayersConstructor( shadowManager = mCompositorChild->SendPLayersConstructor(
backendHint, 0, &parentBackend, &maxTextureSize); backendHint, 0, &parentBackend, &maxTextureSize);
@ -1314,7 +1314,7 @@ PRUint32
nsBaseWidget::GetGLFrameBufferFormat() nsBaseWidget::GetGLFrameBufferFormat()
{ {
if (mLayerManager && if (mLayerManager &&
mLayerManager->GetBackendType() == LayerManager::LAYERS_OPENGL) { mLayerManager->GetBackendType() == LAYERS_OPENGL) {
// Assume that the default framebuffer has RGBA format. Specific // Assume that the default framebuffer has RGBA format. Specific
// backends that know differently will override this method. // backends that know differently will override this method.
return LOCAL_GL_RGBA; return LOCAL_GL_RGBA;

3
widget/xpwidgets/nsBaseWidget.h
View File

@ -15,6 +15,7 @@
#include "nsAutoPtr.h" #include "nsAutoPtr.h"
#include "BasicLayers.h" #include "BasicLayers.h"
#include "nsIRollupListener.h" #include "nsIRollupListener.h"
#include "LayersBackend.h"
class nsIContent; class nsIContent;
class nsAutoRollup; class nsAutoRollup;
@ -98,7 +99,7 @@ public:
NS_IMETHOD MakeFullScreen(bool aFullScreen); NS_IMETHOD MakeFullScreen(bool aFullScreen);
virtual nsDeviceContext* GetDeviceContext(); virtual nsDeviceContext* GetDeviceContext();
virtual LayerManager* GetLayerManager(PLayersChild* aShadowManager = nsnull, virtual LayerManager* GetLayerManager(PLayersChild* aShadowManager = nsnull,
LayersBackend aBackendHint = LayerManager::LAYERS_NONE, LayersBackend aBackendHint = mozilla::layers::LAYERS_NONE,
LayerManagerPersistence aPersistence = LAYER_MANAGER_CURRENT, LayerManagerPersistence aPersistence = LAYER_MANAGER_CURRENT,
bool* aAllowRetaining = nsnull); bool* aAllowRetaining = nsnull);