Bug 877382 - Remove THEBES_API decorator. - r=BenWa
authorJeff Gilbert <jgilbert@mozilla.com>
Wed, 29 May 2013 14:59:24 -0700
changeset 144845 8fed67bc814d173ddba7083a1a6e6669456b7a2e
parent 144844 12f538f501b99d0ff9d63aa2a13cec1d13f3d236
child 144846 06889c22f8c62a153e1ec99ac715acba791aacbe
push idunknown
push userunknown
push dateunknown
reviewersBenWa
bugs877382
milestone24.0a1
Bug 877382 - Remove THEBES_API decorator. - r=BenWa
dom/plugins/ipc/PluginUtilsOSX.h
gfx/2d/QuartzSupport.h
gfx/gl/GLContext.h
gfx/gl/GLContextProviderImpl.h
gfx/layers/FrameMetrics.h
gfx/layers/GonkIOSurfaceImage.h
gfx/layers/GrallocImages.h
gfx/layers/ImageContainer.h
gfx/layers/ImageLayers.h
gfx/layers/Layers.h
gfx/layers/ReadbackLayer.h
gfx/layers/SharedTextureImage.h
gfx/layers/basic/BasicLayers.h
gfx/layers/composite/LayerManagerComposite.h
gfx/layers/d3d10/CanvasLayerD3D10.h
gfx/layers/d3d10/ImageLayerD3D10.h
gfx/layers/d3d10/LayerManagerD3D10.h
gfx/layers/d3d10/ReadbackLayerD3D10.h
gfx/layers/d3d9/CanvasLayerD3D9.h
gfx/layers/d3d9/ColorLayerD3D9.h
gfx/layers/d3d9/DeviceManagerD3D9.h
gfx/layers/d3d9/ImageLayerD3D9.h
gfx/layers/d3d9/LayerManagerD3D9.h
gfx/layers/d3d9/ReadbackLayerD3D9.h
gfx/layers/opengl/CanvasLayerOGL.h
gfx/layers/opengl/ColorLayerOGL.h
gfx/layers/opengl/Composer2D.h
gfx/layers/opengl/ImageLayerOGL.cpp
gfx/layers/opengl/ImageLayerOGL.h
gfx/layers/opengl/LayerManagerOGL.h
gfx/thebes/gfx3DMatrix.h
gfx/thebes/gfxASurface.h
gfx/thebes/gfxAlphaRecovery.h
gfx/thebes/gfxAndroidPlatform.h
gfx/thebes/gfxBaseSharedMemorySurface.h
gfx/thebes/gfxBlur.h
gfx/thebes/gfxCachedTempSurface.h
gfx/thebes/gfxColor.h
gfx/thebes/gfxContext.h
gfx/thebes/gfxD2DSurface.h
gfx/thebes/gfxDrawable.h
gfx/thebes/gfxFT2Fonts.h
gfx/thebes/gfxFont.h
gfx/thebes/gfxFontFeatures.h
gfx/thebes/gfxFontMissingGlyphs.h
gfx/thebes/gfxFontTest.h
gfx/thebes/gfxFontUtils.h
gfx/thebes/gfxGdkNativeRenderer.h
gfx/thebes/gfxImageSurface.h
gfx/thebes/gfxLineSegment.h
gfx/thebes/gfxMatrix.h
gfx/thebes/gfxOS2Fonts.h
gfx/thebes/gfxOS2Platform.h
gfx/thebes/gfxOS2Surface.h
gfx/thebes/gfxPDFSurface.h
gfx/thebes/gfxPSSurface.h
gfx/thebes/gfxPangoFonts.h
gfx/thebes/gfxPath.h
gfx/thebes/gfxPattern.h
gfx/thebes/gfxPlatform.h
gfx/thebes/gfxPlatformGtk.h
gfx/thebes/gfxPlatformMac.h
gfx/thebes/gfxPoint.h
gfx/thebes/gfxPoint3D.h
gfx/thebes/gfxPointH3D.h
gfx/thebes/gfxQPainterSurface.h
gfx/thebes/gfxQtNativeRenderer.h
gfx/thebes/gfxQtPlatform.h
gfx/thebes/gfxQuad.h
gfx/thebes/gfxQuartzImageSurface.h
gfx/thebes/gfxQuartzNativeDrawing.h
gfx/thebes/gfxQuartzSurface.h
gfx/thebes/gfxQuaternion.h
gfx/thebes/gfxRect.h
gfx/thebes/gfxSkipChars.h
gfx/thebes/gfxTeeSurface.h
gfx/thebes/gfxTypes.h
gfx/thebes/gfxUserFontSet.h
gfx/thebes/gfxUtils.h
gfx/thebes/gfxWindowsNativeDrawing.h
gfx/thebes/gfxWindowsPlatform.h
gfx/thebes/gfxWindowsSurface.h
gfx/thebes/gfxXlibNativeRenderer.h
gfx/thebes/gfxXlibSurface.h
gfx/thebes/nsSurfaceTexture.h
--- a/dom/plugins/ipc/PluginUtilsOSX.h
+++ b/dom/plugins/ipc/PluginUtilsOSX.h
@@ -35,17 +35,17 @@ bool SetProcessName(const char* aProcess
 /*
  * Provides a wrapper around nsCARenderer to manage double buffering
  * without having to unbind nsCARenderer on every surface swaps.
  *
  * The double buffer renderer begins with no initialize surfaces.
  * The buffers can be initialized and cleared individually.
  * Swapping still occurs regardless if the buffers are initialized.
  */
-class THEBES_API nsDoubleBufferCARenderer {
+class nsDoubleBufferCARenderer {
 public:
   nsDoubleBufferCARenderer() : mCALayer(nullptr), mContentsScaleFactor(1.0) {}
   // Returns width in "display pixels".  A "display pixel" is the smallest
   // fully addressable part of a display.  But in HiDPI modes each "display
   // pixel" corresponds to more than one device pixel.  Multiply display pixels
   // by mContentsScaleFactor to get device pixels.
   size_t GetFrontSurfaceWidth();
   // Returns height in "display pixels".  Multiply by
--- a/gfx/2d/QuartzSupport.h
+++ b/gfx/2d/QuartzSupport.h
@@ -10,17 +10,17 @@
 
 #import <OpenGL/OpenGL.h>
 #import "ApplicationServices/ApplicationServices.h"
 #include "gfxTypes.h"
 #include "mozilla/RefPtr.h"
 #include "mozilla/gfx/MacIOSurface.h"
 
 // Get the system color space.
-CGColorSpaceRef THEBES_API CreateSystemColorSpace();
+CGColorSpaceRef CreateSystemColorSpace();
 
 // Manages a CARenderer
 struct _CGLPBufferObject;
 struct _CGLContextObject;
 
 enum AllowOfflineRendererEnum { ALLOW_OFFLINE_RENDERER, DISALLOW_OFFLINE_RENDERER };
 
 class nsCARenderer : public mozilla::RefCounted<nsCARenderer> {
--- a/gfx/gl/GLContext.h
+++ b/gfx/gl/GLContext.h
@@ -200,17 +200,17 @@ public:
     }
 
     void SetUserData(void *aKey, void *aValue) {
         mUserData.Put(aKey, aValue);
     }
 
     // Mark this context as destroyed.  This will NULL out all
     // the GL function pointers!
-    void THEBES_API MarkDestroyed();
+    void MarkDestroyed();
 
     bool IsDestroyed() {
         // MarkDestroyed will mark all these as null.
         return mSymbols.fUseProgram == nullptr;
     }
 
     enum NativeDataType {
       NativeGLContext,
@@ -805,17 +805,17 @@ public:
 
     /**
      * Call ReadPixels into an existing gfxImageSurface.
      * The image surface must be using image format RGBA32 or RGB24,
      * and must have stride == width*4.
      * Note that neither ReadPixelsIntoImageSurface nor
      * ReadScreenIntoImageSurface call dest->Flush/MarkDirty.
      */
-    void THEBES_API ReadPixelsIntoImageSurface(gfxImageSurface* dest);
+    void ReadPixelsIntoImageSurface(gfxImageSurface* dest);
 
     // Similar to ReadPixelsIntoImageSurface, but pulls from the screen
     // instead of the currently bound framebuffer.
     void ReadScreenIntoImageSurface(gfxImageSurface* dest);
 
     /**
      * Copy a rectangle from one TextureImage into another.  The
      * source and destination are given in integer coordinates, and
@@ -2863,30 +2863,30 @@ public:
         ASSERT_SYMBOL_PRESENT(fEGLImageTargetRenderbufferStorage);
         mSymbols.fEGLImageTargetRenderbufferStorage(target, image);
         AFTER_GL_CALL;
     }
 
 #undef ASSERT_SYMBOL_PRESENT
 
 #ifdef DEBUG
-    void THEBES_API CreatedProgram(GLContext *aOrigin, GLuint aName);
-    void THEBES_API CreatedShader(GLContext *aOrigin, GLuint aName);
-    void THEBES_API CreatedBuffers(GLContext *aOrigin, GLsizei aCount, GLuint *aNames);
-    void THEBES_API CreatedQueries(GLContext *aOrigin, GLsizei aCount, GLuint *aNames);
-    void THEBES_API CreatedTextures(GLContext *aOrigin, GLsizei aCount, GLuint *aNames);
-    void THEBES_API CreatedFramebuffers(GLContext *aOrigin, GLsizei aCount, GLuint *aNames);
-    void THEBES_API CreatedRenderbuffers(GLContext *aOrigin, GLsizei aCount, GLuint *aNames);
-    void THEBES_API DeletedProgram(GLContext *aOrigin, GLuint aName);
-    void THEBES_API DeletedShader(GLContext *aOrigin, GLuint aName);
-    void THEBES_API DeletedBuffers(GLContext *aOrigin, GLsizei aCount, GLuint *aNames);
-    void THEBES_API DeletedQueries(GLContext *aOrigin, GLsizei aCount, GLuint *aNames);
-    void THEBES_API DeletedTextures(GLContext *aOrigin, GLsizei aCount, GLuint *aNames);
-    void THEBES_API DeletedFramebuffers(GLContext *aOrigin, GLsizei aCount, GLuint *aNames);
-    void THEBES_API DeletedRenderbuffers(GLContext *aOrigin, GLsizei aCount, GLuint *aNames);
+    void CreatedProgram(GLContext *aOrigin, GLuint aName);
+    void CreatedShader(GLContext *aOrigin, GLuint aName);
+    void CreatedBuffers(GLContext *aOrigin, GLsizei aCount, GLuint *aNames);
+    void CreatedQueries(GLContext *aOrigin, GLsizei aCount, GLuint *aNames);
+    void CreatedTextures(GLContext *aOrigin, GLsizei aCount, GLuint *aNames);
+    void CreatedFramebuffers(GLContext *aOrigin, GLsizei aCount, GLuint *aNames);
+    void CreatedRenderbuffers(GLContext *aOrigin, GLsizei aCount, GLuint *aNames);
+    void DeletedProgram(GLContext *aOrigin, GLuint aName);
+    void DeletedShader(GLContext *aOrigin, GLuint aName);
+    void DeletedBuffers(GLContext *aOrigin, GLsizei aCount, GLuint *aNames);
+    void DeletedQueries(GLContext *aOrigin, GLsizei aCount, GLuint *aNames);
+    void DeletedTextures(GLContext *aOrigin, GLsizei aCount, GLuint *aNames);
+    void DeletedFramebuffers(GLContext *aOrigin, GLsizei aCount, GLuint *aNames);
+    void DeletedRenderbuffers(GLContext *aOrigin, GLsizei aCount, GLuint *aNames);
 
     void SharedContextDestroyed(GLContext *aChild);
     void ReportOutstandingNames();
 
     struct NamedResource {
         NamedResource()
             : origin(nullptr), name(0), originDeleted(false)
         { }
--- a/gfx/gl/GLContextProviderImpl.h
+++ b/gfx/gl/GLContextProviderImpl.h
@@ -6,17 +6,17 @@
 #ifndef IN_GL_CONTEXT_PROVIDER_H
 #error GLContextProviderImpl.h must only be included from GLContextProvider.h
 #endif
 
 #ifndef GL_CONTEXT_PROVIDER_NAME
 #error GL_CONTEXT_PROVIDER_NAME not defined
 #endif
 
-class THEBES_API GL_CONTEXT_PROVIDER_NAME
+class GL_CONTEXT_PROVIDER_NAME
 {
 public:
     typedef GLContext::ContextFlags ContextFlags;
     typedef gfx::SurfaceCaps SurfaceCaps;
     /**
      * Create a context that renders to the surface of the widget that is
      * passed in.  The context is always created with an RGB pixel format,
      * with no alpha, depth or stencil.  If any of those features are needed,
--- a/gfx/layers/FrameMetrics.h
+++ b/gfx/layers/FrameMetrics.h
@@ -15,17 +15,17 @@ namespace mozilla {
 namespace layers {
 
 /**
  * The viewport and displayport metrics for the painted frame at the
  * time of a layer-tree transaction.  These metrics are especially
  * useful for shadow layers, because the metrics values are updated
  * atomically with new pixels.
  */
-struct THEBES_API FrameMetrics {
+struct FrameMetrics {
 public:
   // We use IDs to identify frames across processes.
   typedef uint64_t ViewID;
   static const ViewID NULL_SCROLL_ID;   // This container layer does not scroll.
   static const ViewID ROOT_SCROLL_ID;   // This is the root scroll frame.
   static const ViewID START_SCROLL_ID;  // This is the ID that scrolling subframes
                                         // will begin at.
 
--- a/gfx/layers/GonkIOSurfaceImage.h
+++ b/gfx/layers/GonkIOSurfaceImage.h
@@ -41,17 +41,17 @@ public:
   {
     return mSurfaceDescriptor;
   }
 
 protected:
   SurfaceDescriptor mSurfaceDescriptor;
 };
 
-class THEBES_API GonkIOSurfaceImage : public Image {
+class GonkIOSurfaceImage : public Image {
   typedef android::GraphicBuffer GraphicBuffer;
   static uint32_t sColorIdMap[];
 public:
   struct Data {
     nsRefPtr<GraphicBufferLocked> mGraphicBuffer;
     gfxIntSize mPicSize;
   };
   GonkIOSurfaceImage()
--- a/gfx/layers/GrallocImages.h
+++ b/gfx/layers/GrallocImages.h
@@ -32,17 +32,17 @@ namespace layers {
  * size = y_size + c_size * 2
  * cr_offset = y_size
  * cb_offset = y_size + c_size
  *
  * The Image that is rendered is the picture region defined by
  * mPicX, mPicY and mPicSize. The size of the rendered image is
  * mPicSize, not mYSize or mCbCrSize.
  */
-class THEBES_API GrallocPlanarYCbCrImage : public PlanarYCbCrImage {
+class GrallocPlanarYCbCrImage : public PlanarYCbCrImage {
   typedef PlanarYCbCrImage::Data Data;
 
 public:
   GrallocPlanarYCbCrImage();
 
   virtual ~GrallocPlanarYCbCrImage();
 
   /**
--- a/gfx/layers/ImageContainer.h
+++ b/gfx/layers/ImageContainer.h
@@ -51,17 +51,17 @@ protected:
  * modified after calling SetImage. Image implementations do not need to
  * perform locking; when filling an Image, the Image client is responsible
  * for ensuring only one thread accesses the Image at a time, and after
  * SetImage the image is immutable.
  * 
  * When resampling an Image, only pixels within the buffer should be
  * sampled. For example, cairo images should be sampled in EXTEND_PAD mode.
  */
-class THEBES_API Image {
+class Image {
   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(Image)
 
 public:
   virtual ~Image() {}
 
 
   ImageFormat GetFormat() { return mFormat; }
   void* GetImplData() { return mImplData; }
@@ -162,17 +162,17 @@ public:
  * This class is not meant to be used directly but rather can be set on an
  * image container. This is usually done by the layer system internally and
  * not explicitly by users. For PlanarYCbCr or Cairo images the default
  * implementation will creates images whose data lives in system memory, for
  * MacIOSurfaces the default implementation will be a simple MacIOSurface
  * wrapper.
  */
 
-class THEBES_API ImageFactory
+class ImageFactory
 {
   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(ImageFactory)
 protected:
   friend class ImageContainer;
 
   ImageFactory() {}
   virtual ~ImageFactory() {}
 
@@ -255,17 +255,17 @@ struct RemoteImageData {
  * a layer transaction.
  * 3) Remote. Initiated by calling SetRemoteImageData on the ImageContainer
  * before any other activity.
  * The ImageContainer uses a shared memory block containing a cross-process mutex
  * to communicate with the compositor thread. SetCurrentImage synchronously
  * updates the shared state to point to the new image and the old image
  * is immediately released (not true in Normal or Asynchronous modes).
  */
-class THEBES_API ImageContainer {
+class ImageContainer {
   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(ImageContainer)
 public:
 
   enum { DISABLE_ASYNC = 0x0, ENABLE_ASYNC = 0x01 };
 
   ImageContainer(int flag = 0);
 
   ~ImageContainer();
@@ -629,17 +629,17 @@ private:
  *  0   3   6   9   12  15  18  21                659             669
  * |----------------------------------------------------------------|
  * |Y___Y___Y___Y___Y___Y___Y___Y...                      |%%%%%%%%%|
  * |Y___Y___Y___Y___Y___Y___Y___Y...                      |%%%%%%%%%|
  * |Y___Y___Y___Y___Y___Y___Y___Y...                      |%%%%%%%%%|
  * |            |<->|
  *                mYSkip
  */
-class THEBES_API PlanarYCbCrImage : public Image {
+class PlanarYCbCrImage : public Image {
 public:
   struct Data {
     // Luminance buffer
     uint8_t* mYChannel;
     int32_t mYStride;
     gfxIntSize mYSize;
     int32_t mYSkip;
     // Chroma buffers
@@ -749,17 +749,17 @@ protected:
   nsRefPtr<BufferRecycleBin> mRecycleBin;
 };
 
 /**
  * Currently, the data in a CairoImage surface is treated as being in the
  * device output color space. This class is very simple as all backends
  * have to know about how to deal with drawing a cairo image.
  */
-class THEBES_API CairoImage : public Image {
+class CairoImage : public Image {
 public:
   struct Data {
     gfxASurface* mSurface;
     gfxIntSize mSize;
   };
 
   /**
    * This can only be called on the main thread. It may add a reference
--- a/gfx/layers/ImageLayers.h
+++ b/gfx/layers/ImageLayers.h
@@ -15,17 +15,17 @@
 namespace mozilla {
 namespace layers {
 
 class ImageContainer;
 
 /**
  * A Layer which renders an Image.
  */
-class THEBES_API ImageLayer : public Layer {
+class ImageLayer : public Layer {
 public:
   enum ScaleMode {
     SCALE_NONE,
     SCALE_STRETCH,
     SCALE_SENTINEL
   // Unimplemented - SCALE_PRESERVE_ASPECT_RATIO_CONTAIN
   };
 
--- a/gfx/layers/Layers.h
+++ b/gfx/layers/Layers.h
@@ -73,17 +73,17 @@ struct EffectMask;
 
 #define MOZ_LAYER_DECL_NAME(n, e)                           \
   virtual const char* Name() const { return n; }            \
   virtual LayerType GetType() const { return e; }
 
 /**
  * Base class for userdata objects attached to layers and layer managers.
  */
-class THEBES_API LayerUserData {
+class LayerUserData {
 public:
   virtual ~LayerUserData() {}
 };
 
 /*
  * Motivation: For truly smooth animation and video playback, we need to
  * be able to compose frames and render them on a dedicated thread (i.e.
  * off the main thread where DOM manipulation, script execution and layout
@@ -132,17 +132,17 @@ static void LayerManagerUserDataDestroy(
  * order. When the client has finished drawing into the ThebesLayers, it should
  * call EndTransaction to complete the transaction.
  *
  * All layer API calls happen on the main thread.
  *
  * Layers are refcounted. The layer manager holds a reference to the
  * root layer, and each container layer holds a reference to its children.
  */
-class THEBES_API LayerManager {
+class LayerManager {
   NS_INLINE_DECL_REFCOUNTING(LayerManager)
 
 public:
   LayerManager()
     : mDestroyed(false)
     , mSnapEffectiveTransforms(true)
     , mId(0)
     , mInTransaction(false)
@@ -584,17 +584,17 @@ struct AnimData {
   InfallibleTArray<nsStyleAnimation::Value> mEndValues;
   InfallibleTArray<nsAutoPtr<mozilla::css::ComputedTimingFunction> > mFunctions;
 };
 
 /**
  * A Layer represents anything that can be rendered onto a destination
  * surface.
  */
-class THEBES_API Layer {
+class Layer {
   NS_INLINE_DECL_REFCOUNTING(Layer)
 
 public:
   // Keep these in alphabetical order
   enum LayerType {
     TYPE_CANVAS,
     TYPE_COLOR,
     TYPE_CONTAINER,
@@ -1266,17 +1266,17 @@ protected:
  * of contents that it is currently storing, which is finite. ThebesLayer
  * implementations can store content between paints.
  *
  * ThebesLayers are rendered into during the drawing phase of a transaction.
  *
  * Currently the contents of a ThebesLayer are in the device output color
  * space.
  */
-class THEBES_API ThebesLayer : public Layer {
+class ThebesLayer : public Layer {
 public:
   /**
    * CONSTRUCTION PHASE ONLY
    * Tell this layer that the content in some region has changed and
    * will need to be repainted. This area is removed from the valid
    * region.
    */
   virtual void InvalidateRegion(const nsIntRegion& aRegion) = 0;
@@ -1364,17 +1364,17 @@ protected:
    */
   bool mAllowResidualTranslation;
 };
 
 /**
  * A Layer which other layers render into. It holds references to its
  * children.
  */
-class THEBES_API ContainerLayer : public Layer {
+class ContainerLayer : public Layer {
 public:
   /**
    * CONSTRUCTION PHASE ONLY
    * Insert aChild into the child list of this container. aChild must
    * not be currently in any child list or the root for the layer manager.
    * If aAfter is non-null, it must be a child of this container and
    * we insert after that layer. If it's null we insert at the start.
    */
@@ -1535,17 +1535,17 @@ protected:
   bool mMayHaveReadbackChild;
 };
 
 /**
  * A Layer which just renders a solid color in its visible region. It actually
  * can fill any area that contains the visible region, so if you need to
  * restrict the area filled, set a clip region on this layer.
  */
-class THEBES_API ColorLayer : public Layer {
+class ColorLayer : public Layer {
 public:
   virtual ColorLayer* AsColorLayer() { return this; }
 
   /**
    * CONSTRUCTION PHASE ONLY
    * Set the color of the layer.
    */
   virtual void SetColor(const gfxRGBA& aColor)
@@ -1585,17 +1585,17 @@ protected:
  * gfxASurface or a GLContext (for WebGL layers), and has some control
  * for intelligent updating from the source if necessary (for example,
  * if hardware compositing is not available, for reading from the GL
  * buffer into an image surface that we can layer composite.)
  *
  * After Initialize is called, the underlying canvas Surface/GLContext
  * must not be modified during a layer transaction.
  */
-class THEBES_API CanvasLayer : public Layer {
+class CanvasLayer : public Layer {
 public:
   struct Data {
     Data()
       : mSurface(nullptr)
       , mDrawTarget(nullptr)
       , mGLContext(nullptr)
       , mSize(0,0)
       , mIsGLAlphaPremult(false)
@@ -1758,17 +1758,17 @@ private:
  *   look up subtree for GetReferentId()
  *   ConnectReferentLayer(subtree)
  *   compose
  *   ClearReferentLayer()
  *
  * Clients will usually want to Connect/Clear() on each transaction to
  * avoid difficulties managing memory across multiple layer subtrees.
  */
-class THEBES_API RefLayer : public ContainerLayer {
+class RefLayer : public ContainerLayer {
   friend class LayerManager;
 
 private:
   virtual void InsertAfter(Layer* aChild, Layer* aAfter)
   { MOZ_NOT_REACHED("no"); }
 
   virtual void RemoveChild(Layer* aChild)
   { MOZ_NOT_REACHED("no"); }
--- a/gfx/layers/ReadbackLayer.h
+++ b/gfx/layers/ReadbackLayer.h
@@ -13,17 +13,17 @@ namespace layers {
 
 class ReadbackProcessor;
 
 /**
  * A ReadbackSink receives a stream of updates to a rectangle of pixels.
  * These update callbacks are always called on the main thread, either during
  * EndTransaction or from the event loop.
  */
-class THEBES_API ReadbackSink {
+class ReadbackSink {
 public:
   ReadbackSink() {}
   virtual ~ReadbackSink() {}
 
   /**
    * Sends an update to indicate that the background is currently unknown.
    */
   virtual void SetUnknown(uint64_t aSequenceNumber) = 0;
@@ -61,17 +61,17 @@ public:
  * ReadbackSink object supplied by the client.
  *
  * This is a "best effort" API; it is possible for the layer system to tell
  * the ReadbackSink that the contents of the readback area are unknown.
  *
  * This API exists to work around the limitations of transparent windowless
  * plugin rendering APIs. It should not be used for anything else.
  */
-class THEBES_API ReadbackLayer : public Layer {
+class ReadbackLayer : public Layer {
 public:
   MOZ_LAYER_DECL_NAME("ReadbackLayer", TYPE_READBACK)
 
   virtual void ComputeEffectiveTransforms(const gfx3DMatrix& aTransformToSurface)
   {
     // Snap our local transform first, and snap the inherited transform as well.
     // This makes our snapping equivalent to what would happen if our content
     // was drawn into a ThebesLayer (gfxContext would snap using the local
--- a/gfx/layers/SharedTextureImage.h
+++ b/gfx/layers/SharedTextureImage.h
@@ -12,17 +12,17 @@
 
 // Split into a separate header from ImageLayers.h due to GLContext.h dependence
 // Implementation remains in ImageLayers.cpp
 
 namespace mozilla {
 
 namespace layers {
 
-class THEBES_API SharedTextureImage : public Image {
+class SharedTextureImage : public Image {
 public:
   struct Data {
     gl::SharedTextureHandle mHandle;
     gl::GLContext::SharedTextureShareType mShareType;
     gfxIntSize mSize;
     bool mInverted;
   };
 
--- a/gfx/layers/basic/BasicLayers.h
+++ b/gfx/layers/basic/BasicLayers.h
@@ -33,17 +33,17 @@ class PaintLayerContext;
 /**
  * This is a cairo/Thebes-only, main-thread-only implementation of layers.
  * 
  * In each transaction, the client sets up the layer tree and then during
  * the drawing phase, each ThebesLayer is painted directly into the target
  * context (with appropriate clipping and Push/PopGroups performed
  * between layers).
  */
-class THEBES_API BasicLayerManager :
+class BasicLayerManager :
     public LayerManager
 {
 public:
   /**
    * Construct a BasicLayerManager which will have no default
    * target context. SetDefaultTarget or BeginTransactionWithTarget
    * must be called for any rendering to happen. ThebesLayers will not
    * be retained.
--- a/gfx/layers/composite/LayerManagerComposite.h
+++ b/gfx/layers/composite/LayerManagerComposite.h
@@ -36,17 +36,17 @@ class ContainerLayerComposite;
 class ImageLayerComposite;
 class CanvasLayerComposite;
 class ColorLayerComposite;
 class RefLayerComposite;
 class CompositableHost;
 class EffectChain;
 class TiledLayerComposer;
 
-class THEBES_API LayerManagerComposite : public LayerManager
+class LayerManagerComposite : public LayerManager
 {
 public:
   LayerManagerComposite(Compositor* aCompositor);
   ~LayerManagerComposite();
   
   virtual void Destroy() MOZ_OVERRIDE;
 
   /**
--- a/gfx/layers/d3d10/CanvasLayerD3D10.h
+++ b/gfx/layers/d3d10/CanvasLayerD3D10.h
@@ -10,18 +10,18 @@
 #include "GLContext.h"
 #include "gfxASurface.h"
 
 #include "mozilla/Preferences.h"
 
 namespace mozilla {
 namespace layers {
 
-class THEBES_API CanvasLayerD3D10 : public CanvasLayer,
-                                    public LayerD3D10
+class CanvasLayerD3D10 : public CanvasLayer,
+                         public LayerD3D10
 {
 public:
   CanvasLayerD3D10(LayerManagerD3D10 *aManager)
     : CanvasLayer(aManager, NULL)
     , LayerD3D10(aManager)
     , mDataIsPremultiplied(false)
     , mNeedsYFlip(false)
     , mHasAlpha(true)
--- a/gfx/layers/d3d10/ImageLayerD3D10.h
+++ b/gfx/layers/d3d10/ImageLayerD3D10.h
@@ -9,18 +9,18 @@
 #include "LayerManagerD3D10.h"
 #include "ImageLayers.h"
 #include "ImageContainer.h"
 #include "yuv_convert.h"
 
 namespace mozilla {
 namespace layers {
 
-class THEBES_API ImageLayerD3D10 : public ImageLayer,
-                                   public LayerD3D10
+class ImageLayerD3D10 : public ImageLayer,
+                        public LayerD3D10
 {
 public:
   ImageLayerD3D10(LayerManagerD3D10 *aManager)
     : ImageLayer(aManager, NULL)
     , LayerD3D10(aManager)
   {
     mImplData = static_cast<LayerD3D10*>(this);
   }
--- a/gfx/layers/d3d10/LayerManagerD3D10.h
+++ b/gfx/layers/d3d10/LayerManagerD3D10.h
@@ -44,17 +44,17 @@ extern cairo_user_data_key_t gKeyD3D10Te
 
 /*
  * This is the LayerManager used for Direct3D 10. For now this will
  * render on the main thread.
  *
  * For the time being, LayerManagerD3D10 forwards layers
  * transactions.
  */
-class THEBES_API LayerManagerD3D10 : public LayerManager {
+class LayerManagerD3D10 : public LayerManager {
 public:
   LayerManagerD3D10(nsIWidget *aWidget);
   virtual ~LayerManagerD3D10();
 
   /*
    * Initializes the layer manager, this is when the layer manager will
    * actually access the device and attempt to create the swap chain used
    * to draw to the window. If this method fails the device cannot be used.
--- a/gfx/layers/d3d10/ReadbackLayerD3D10.h
+++ b/gfx/layers/d3d10/ReadbackLayerD3D10.h
@@ -7,17 +7,17 @@
 #define GFX_READBACKLAYERD3D10_H
 
 #include "LayerManagerD3D10.h"
 #include "ReadbackLayer.h"
 
 namespace mozilla {
 namespace layers {
 
-class THEBES_API ReadbackLayerD3D10 :
+class ReadbackLayerD3D10 :
   public ReadbackLayer,
   public LayerD3D10
 {
 public:
     ReadbackLayerD3D10(LayerManagerD3D10 *aManager)
     : ReadbackLayer(aManager, NULL),
       LayerD3D10(aManager)
   {
--- a/gfx/layers/d3d9/CanvasLayerD3D9.h
+++ b/gfx/layers/d3d9/CanvasLayerD3D9.h
@@ -9,17 +9,17 @@
 #include "LayerManagerD3D9.h"
 #include "GLContext.h"
 #include "gfxASurface.h"
 
 namespace mozilla {
 namespace layers {
 
 
-class THEBES_API CanvasLayerD3D9 :
+class CanvasLayerD3D9 :
   public CanvasLayer,
   public LayerD3D9
 {
 public:
   CanvasLayerD3D9(LayerManagerD3D9 *aManager)
     : CanvasLayer(aManager, NULL)
     , LayerD3D9(aManager)
     , mDataIsPremultiplied(false)
--- a/gfx/layers/d3d9/ColorLayerD3D9.h
+++ b/gfx/layers/d3d9/ColorLayerD3D9.h
@@ -6,18 +6,18 @@
 #ifndef GFX_COLORLAYERD3D9_H
 #define GFX_COLORLAYERD3D9_H
 
 #include "LayerManagerD3D9.h"
 
 namespace mozilla {
 namespace layers {
 
-class THEBES_API ColorLayerD3D9 : public ColorLayer,
-                                 public LayerD3D9
+class ColorLayerD3D9 : public ColorLayer,
+                       public LayerD3D9
 {
 public:
   ColorLayerD3D9(LayerManagerD3D9 *aManager)
     : ColorLayer(aManager, NULL)
     , LayerD3D9(aManager)
   {
     mImplData = static_cast<LayerD3D9*>(this);
   }
--- a/gfx/layers/d3d9/DeviceManagerD3D9.h
+++ b/gfx/layers/d3d9/DeviceManagerD3D9.h
@@ -27,17 +27,17 @@ const int CBvRenderTargetOffset = 8;
 const int CBvTextureCoords = 9;
 const int CBvLayerQuad = 10;
 const int CBfLayerOpacity = 0;
 
 /**
  * SwapChain class, this class manages the swap chain belonging to a
  * LayerManagerD3D9.
  */
-class THEBES_API SwapChainD3D9
+class SwapChainD3D9
 {
   NS_INLINE_DECL_REFCOUNTING(SwapChainD3D9)
 public:
   ~SwapChainD3D9();
 
   /**
    * This function will prepare the device this swap chain belongs to for
    * rendering to this swap chain. Only after calling this function can the
@@ -74,17 +74,17 @@ private:
   HWND mWnd;
 };
 
 /**
  * Device manager, this class is used by the layer managers to share the D3D9
  * device and create swap chains for the individual windows the layer managers
  * belong to.
  */
-class THEBES_API DeviceManagerD3D9 MOZ_FINAL
+class DeviceManagerD3D9 MOZ_FINAL
 {
 public:
   DeviceManagerD3D9();
   NS_IMETHOD_(nsrefcnt) AddRef(void);
   NS_IMETHOD_(nsrefcnt) Release(void);
 protected:
   nsAutoRefCnt mRefCnt;
   NS_DECL_OWNINGTHREAD
--- a/gfx/layers/d3d9/ImageLayerD3D9.h
+++ b/gfx/layers/d3d9/ImageLayerD3D9.h
@@ -9,18 +9,18 @@
 #include "LayerManagerD3D9.h"
 #include "ImageLayers.h"
 #include "ImageContainer.h"
 #include "yuv_convert.h"
 
 namespace mozilla {
 namespace layers {
 
-class THEBES_API ImageLayerD3D9 : public ImageLayer,
-                                  public LayerD3D9
+class ImageLayerD3D9 : public ImageLayer,
+                       public LayerD3D9
 {
 public:
   ImageLayerD3D9(LayerManagerD3D9 *aManager)
     : ImageLayer(aManager, NULL)
     , LayerD3D9(aManager)
   {
     mImplData = static_cast<LayerD3D9*>(this);
   }
@@ -31,17 +31,17 @@ public:
   virtual void RenderLayer();
 
   virtual already_AddRefed<IDirect3DTexture9> GetAsTexture(gfxIntSize* aSize);
 
 private:
   IDirect3DTexture9* GetTexture(Image *aImage, bool& aHasAlpha);
 };
 
-class THEBES_API ImageD3D9
+class ImageD3D9
 {
 public:
   virtual already_AddRefed<gfxASurface> GetAsSurface() = 0;
 };
 
 
 struct TextureD3D9BackendData : public ImageBackendData
 {
--- a/gfx/layers/d3d9/LayerManagerD3D9.h
+++ b/gfx/layers/d3d9/LayerManagerD3D9.h
@@ -51,17 +51,17 @@ struct ShaderConstantRect
   // For easy passing to SetVertexShaderConstantF.
   operator float* () { return &mX; }
 };
 
 /*
  * This is the LayerManager used for Direct3D 9. For now this will render on
  * the main thread.
  */
-class THEBES_API LayerManagerD3D9 : public LayerManager {
+class LayerManagerD3D9 : public LayerManager {
 public:
   LayerManagerD3D9(nsIWidget *aWidget);
   virtual ~LayerManagerD3D9();
 
   /*
    * Initializes the layer manager, this is when the layer manager will
    * actually access the device and attempt to create the swap chain used
    * to draw to the window. If this method fails the device cannot be used.
--- a/gfx/layers/d3d9/ReadbackLayerD3D9.h
+++ b/gfx/layers/d3d9/ReadbackLayerD3D9.h
@@ -7,17 +7,17 @@
 #define GFX_READBACKLAYERD3D9_H
 
 #include "LayerManagerD3D9.h"
 #include "ReadbackLayer.h"
 
 namespace mozilla {
 namespace layers {
 
-class THEBES_API ReadbackLayerD3D9 :
+class ReadbackLayerD3D9 :
   public ReadbackLayer,
   public LayerD3D9
 {
 public:
     ReadbackLayerD3D9(LayerManagerD3D9 *aManager)
     : ReadbackLayer(aManager, NULL),
       LayerD3D9(aManager)
   {
--- a/gfx/layers/opengl/CanvasLayerOGL.h
+++ b/gfx/layers/opengl/CanvasLayerOGL.h
@@ -15,17 +15,17 @@
 #include "GLXLibrary.h"
 #include "mozilla/X11Util.h"
 #endif
 
 
 namespace mozilla {
 namespace layers {
 
-class THEBES_API CanvasLayerOGL :
+class CanvasLayerOGL :
   public CanvasLayer,
   public LayerOGL
 {
 public:
   CanvasLayerOGL(LayerManagerOGL *aManager)
     : CanvasLayer(aManager, NULL)
     , LayerOGL(aManager)
     , mLayerProgram(gl::RGBALayerProgramType)
--- a/gfx/layers/opengl/ColorLayerOGL.h
+++ b/gfx/layers/opengl/ColorLayerOGL.h
@@ -9,18 +9,18 @@
 #include "mozilla/layers/PLayerTransaction.h"
 #include "mozilla/layers/ShadowLayers.h"
 
 #include "LayerManagerOGL.h"
 
 namespace mozilla {
 namespace layers {
 
-class THEBES_API ColorLayerOGL : public ColorLayer,
-                                 public LayerOGL
+class ColorLayerOGL : public ColorLayer,
+                      public LayerOGL
 {
 public:
   ColorLayerOGL(LayerManagerOGL *aManager)
     : ColorLayer(aManager, NULL)
     , LayerOGL(aManager)
   { 
     mImplData = static_cast<LayerOGL*>(this);
   }
--- a/gfx/layers/opengl/Composer2D.h
+++ b/gfx/layers/opengl/Composer2D.h
@@ -28,17 +28,17 @@
 
 class gfxMatrix;
 
 namespace mozilla {
 namespace layers {
 
 class Layer;
 
-class THEBES_API Composer2D {
+class Composer2D {
   NS_INLINE_DECL_REFCOUNTING(Composer2D)
 
 public:
   virtual ~Composer2D() {}
 
   /**
    * Return true if |aRoot| met the implementation's criteria for fast
    * composition and the render was successful.  Return false to fall
--- a/gfx/layers/opengl/ImageLayerOGL.cpp
+++ b/gfx/layers/opengl/ImageLayerOGL.cpp
@@ -138,17 +138,17 @@ TextureRecycleBin::GetTexture(TextureTyp
     aOutTexture->Allocate(aContext);
     return;
   }
   uint32_t last = mRecycledTextures[aType].Length() - 1;
   aOutTexture->TakeFrom(&mRecycledTextures[aType].ElementAt(last));
   mRecycledTextures[aType].RemoveElementAt(last);
 }
 
-struct THEBES_API ImageOGLBackendData : public ImageBackendData
+struct ImageOGLBackendData : public ImageBackendData
 {
   GLTexture mTexture;
 };
 
 void
 AllocateTextureSharedTexture(SharedTextureImage *aTexImage, mozilla::gl::GLContext* aGL, GLenum aTarget)
 {
   nsAutoPtr<ImageOGLBackendData> backendData(
--- a/gfx/layers/opengl/ImageLayerOGL.h
+++ b/gfx/layers/opengl/ImageLayerOGL.h
@@ -93,18 +93,18 @@ private:
   // This protects mRecycledBuffers, mRecycledBufferSize, mRecycledTextures
   // and mRecycledTextureSizes
   Mutex mLock;
 
   nsTArray<GLTexture> mRecycledTextures[2];
   gfxIntSize mRecycledTextureSizes[2];
 };
 
-class THEBES_API ImageLayerOGL : public ImageLayer,
-                                 public LayerOGL
+class ImageLayerOGL : public ImageLayer,
+                      public LayerOGL
 {
 public:
   ImageLayerOGL(LayerManagerOGL *aManager);
   ~ImageLayerOGL() { Destroy(); }
 
   // LayerOGL Implementation
   virtual void Destroy() { mDestroyed = true; }
   virtual Layer* GetLayer();
@@ -117,17 +117,17 @@ public:
 
   void AllocateTexturesYCbCr(PlanarYCbCrImage *aImage);
   void AllocateTexturesCairo(CairoImage *aImage);
 
 protected:
   nsRefPtr<TextureRecycleBin> mTextureRecycleBin;
 };
 
-struct THEBES_API PlanarYCbCrOGLBackendData : public ImageBackendData
+struct PlanarYCbCrOGLBackendData : public ImageBackendData
 {
   ~PlanarYCbCrOGLBackendData()
   {
     if (HasTextures()) {
       mTextureRecycleBin->RecycleTexture(&mTextures[0], TextureRecycleBin::TEXTURE_Y, mYSize);
       mTextureRecycleBin->RecycleTexture(&mTextures[1], TextureRecycleBin::TEXTURE_C, mCbCrSize);
       mTextureRecycleBin->RecycleTexture(&mTextures[2], TextureRecycleBin::TEXTURE_C, mCbCrSize);
     }
--- a/gfx/layers/opengl/LayerManagerOGL.h
+++ b/gfx/layers/opengl/LayerManagerOGL.h
@@ -38,17 +38,17 @@ class ImageLayerComposite;
 class CanvasLayerComposite;
 class ColorLayerComposite;
 struct FPSState;
 
 /**
  * This is the LayerManager used for OpenGL 2.1 and OpenGL ES 2.0.
  * This should be used only on the main thread.
  */
-class THEBES_API LayerManagerOGL : public LayerManager
+class LayerManagerOGL : public LayerManager
 {
   typedef mozilla::gl::GLContext GLContext;
   typedef mozilla::gl::ShaderProgramType ProgramType;
 
 public:
   LayerManagerOGL(nsIWidget *aWidget, int aSurfaceWidth = -1, int aSurfaceHeight = -1,
                   bool aIsRenderingToEGLSurface = false);
   virtual ~LayerManagerOGL();
--- a/gfx/thebes/gfx3DMatrix.h
+++ b/gfx/thebes/gfx3DMatrix.h
@@ -22,17 +22,17 @@
  * _41 _42 _43 _44
  *
  * This matrix is treated as row-major. Assuming we consider our vectors row
  * vectors, this matrix type will be identical in memory to the OpenGL and D3D
  * matrices. OpenGL matrices are column-major, however OpenGL also treats
  * vectors as column vectors, the double transposition makes everything work
  * out nicely.
  */
-class THEBES_API gfx3DMatrix
+class gfx3DMatrix
 {
 public:
   /**
    * Create matrix.
    */
   gfx3DMatrix(void);
 
   /**
--- a/gfx/thebes/gfxASurface.h
+++ b/gfx/thebes/gfxASurface.h
@@ -24,17 +24,17 @@ typedef void (*thebes_destroy_func_t) (v
 class gfxImageSurface;
 struct nsIntPoint;
 struct nsIntRect;
 
 /**
  * A surface is something you can draw on. Instantiate a subclass of this
  * abstract class, and use gfxContext to draw on this surface.
  */
-class THEBES_API gfxASurface {
+class gfxASurface {
 public:
 #ifdef MOZILLA_INTERNAL_API
     nsrefcnt AddRef(void);
     nsrefcnt Release(void);
 
     // These functions exist so that browsercomps can refcount a gfxASurface
     virtual nsrefcnt AddRefExternal(void)
     {
@@ -347,17 +347,17 @@ private:
 protected:
     bool mSurfaceValid;
     bool mAllowUseAsSource;
 };
 
 /**
  * An Unknown surface; used to wrap unknown cairo_surface_t returns from cairo
  */
-class THEBES_API gfxUnknownSurface : public gfxASurface {
+class gfxUnknownSurface : public gfxASurface {
 public:
     gfxUnknownSurface(cairo_surface_t *surf) {
         Init(surf, true);
     }
 
     virtual ~gfxUnknownSurface() { }
 };
 
--- a/gfx/thebes/gfxAlphaRecovery.h
+++ b/gfx/thebes/gfxAlphaRecovery.h
@@ -6,17 +6,17 @@
 #ifndef _GFXALPHARECOVERY_H_
 #define _GFXALPHARECOVERY_H_
 
 #include "gfxContext.h"
 #include "gfxImageSurface.h"
 #include "mozilla/SSE.h"
 #include "nsRect.h"
 
-class THEBES_API gfxAlphaRecovery {
+class gfxAlphaRecovery {
 public:
     struct Analysis {
         bool uniformColor;
         bool uniformAlpha;
         gfxFloat alpha;
         gfxFloat r, g, b;
     };
 
--- a/gfx/thebes/gfxAndroidPlatform.h
+++ b/gfx/thebes/gfxAndroidPlatform.h
@@ -15,17 +15,17 @@ namespace mozilla {
     namespace dom {
         class FontListEntry;
     };
 };
 using mozilla::dom::FontListEntry;
 
 typedef struct FT_LibraryRec_ *FT_Library;
 
-class THEBES_API gfxAndroidPlatform : public gfxPlatform {
+class gfxAndroidPlatform : public gfxPlatform {
 public:
     gfxAndroidPlatform();
     virtual ~gfxAndroidPlatform();
 
     static gfxAndroidPlatform *GetPlatform() {
         return (gfxAndroidPlatform*) gfxPlatform::GetPlatform();
     }
 
--- a/gfx/thebes/gfxBaseSharedMemorySurface.h
+++ b/gfx/thebes/gfxBaseSharedMemorySurface.h
@@ -25,17 +25,17 @@ GetShmInfoPtr(const mozilla::ipc::Shmem&
 {
     return reinterpret_cast<SharedImageInfo*>
         (aShmem.get<char>() + aShmem.Size<char>() - sizeof(SharedImageInfo));
 }
 
 extern const cairo_user_data_key_t SHM_KEY;
 
 template <typename Base, typename Sub>
-class THEBES_API gfxBaseSharedMemorySurface : public Base {
+class gfxBaseSharedMemorySurface : public Base {
     typedef mozilla::ipc::SharedMemory SharedMemory;
     typedef mozilla::ipc::Shmem Shmem;
 
 public:
     virtual ~gfxBaseSharedMemorySurface()
     {
         MOZ_COUNT_DTOR(gfxBaseSharedMemorySurface);
     }
--- a/gfx/thebes/gfxBlur.h
+++ b/gfx/thebes/gfxBlur.h
@@ -30,17 +30,17 @@ namespace mozilla {
  * 
  * A spread N makes each output pixel the maximum value of all source
  * pixels within a square of side length 2N+1 centered on the output pixel.
  * 
  * A temporary surface is created in the Init function. The caller then draws
  * any desired content onto the context acquired through GetContext, and lastly
  * calls Paint to apply the blurred content as an alpha mask.
  */
-class THEBES_API gfxAlphaBoxBlur
+class gfxAlphaBoxBlur
 {
 public:
     gfxAlphaBoxBlur();
 
     ~gfxAlphaBoxBlur();
 
     /**
      * Constructs a box blur and initializes the temporary surface.
--- a/gfx/thebes/gfxCachedTempSurface.h
+++ b/gfx/thebes/gfxCachedTempSurface.h
@@ -17,17 +17,17 @@ class gfxContext;
  * Large resource allocations may have an overhead that can be avoided by
  * caching.  Caching also alows the system to use history in deciding whether
  * to manage the surfaces in video or system memory.
  *
  * However, because we don't want to set aside megabytes of unused resources
  * unncessarily, these surfaces are released on a timer.
  */
 
-class THEBES_API gfxCachedTempSurface {
+class gfxCachedTempSurface {
 public:
   /**
    * Returns a context for a surface that can be efficiently copied to
    * |aSimilarTo|.
    *
    * When |aContentType| has an alpha component, the surface will be cleared.
    * For opaque surfaces, the initial surface contents are undefined.
    * When |aContentType| differs in different invocations this is handled
--- a/gfx/thebes/gfxColor.h
+++ b/gfx/thebes/gfxColor.h
@@ -102,17 +102,17 @@ gfxPackedPixel(uint8_t a, uint8_t r, uin
 
 /**
  * A color value, storing red, green, blue and alpha components.
  * This class does not use premultiplied alpha.
  *
  * XXX should this use doubles (instead of gfxFloat), for consistency with
  * cairo?
  */
-struct THEBES_API gfxRGBA {
+struct gfxRGBA {
     gfxFloat r, g, b, a;
 
     enum PackedColorType {
         PACKED_ABGR,
         PACKED_ABGR_PREMULTIPLIED,
 
         PACKED_ARGB,
         PACKED_ARGB_PREMULTIPLIED,
--- a/gfx/thebes/gfxContext.h
+++ b/gfx/thebes/gfxContext.h
@@ -33,17 +33,17 @@ template <typename T> class FallibleTArr
  * All drawing happens by creating a path and then stroking or filling it.
  * The functions like Rectangle and Arc do not do any drawing themselves.
  * When a path is drawn (stroked or filled), it is filled/stroked with a
  * pattern set by SetPattern, SetColor or SetSource.
  *
  * Note that the gfxContext takes coordinates in device pixels,
  * as opposed to app units.
  */
-class THEBES_API gfxContext {
+class gfxContext {
     NS_INLINE_DECL_REFCOUNTING(gfxContext)
 
 public:
     /**
      * Initialize this context from a surface.
      */
     gfxContext(gfxASurface *surface);
 
@@ -795,17 +795,17 @@ private:
   mozilla::RefPtr<DrawTarget> mOriginalDT;
 };
 
 /**
  * Sentry helper class for functions with multiple return points that need to
  * call Save() on a gfxContext and have Restore() called automatically on the
  * gfxContext before they return.
  */
-class THEBES_API gfxContextAutoSaveRestore
+class gfxContextAutoSaveRestore
 {
 public:
   gfxContextAutoSaveRestore() : mContext(nullptr) {}
 
   gfxContextAutoSaveRestore(gfxContext *aContext) : mContext(aContext) {
     mContext->Save();
   }
 
@@ -837,17 +837,17 @@ private:
 
 /**
  * Sentry helper class for functions with multiple return points that need to
  * back up the current path of a context and have it automatically restored
  * before they return. This class assumes that the transformation matrix will
  * be the same when Save and Restore are called. The calling function must
  * ensure that this is the case or the path will be copied incorrectly.
  */
-class THEBES_API gfxContextPathAutoSaveRestore
+class gfxContextPathAutoSaveRestore
 {
 public:
     gfxContextPathAutoSaveRestore() : mContext(nullptr) {}
 
     gfxContextPathAutoSaveRestore(gfxContext *aContext, bool aSave = true) : mContext(aContext)
     {
         if (aSave)
             Save();       
@@ -895,17 +895,17 @@ private:
     nsRefPtr<gfxPath> mPath;
 };
 
 /**
  * Sentry helper class for functions with multiple return points that need to
  * back up the current matrix of a context and have it automatically restored
  * before they return.
  */
-class THEBES_API gfxContextMatrixAutoSaveRestore
+class gfxContextMatrixAutoSaveRestore
 {
 public:
     gfxContextMatrixAutoSaveRestore(gfxContext *aContext) :
         mContext(aContext), mMatrix(aContext->CurrentMatrix())
     {
     }
 
     ~gfxContextMatrixAutoSaveRestore()
@@ -919,17 +919,17 @@ public:
     }
 
 private:
     gfxContext *mContext;
     gfxMatrix   mMatrix;
 };
 
 
-class THEBES_API gfxContextAutoDisableSubpixelAntialiasing {
+class gfxContextAutoDisableSubpixelAntialiasing {
 public:
     gfxContextAutoDisableSubpixelAntialiasing(gfxContext *aContext, bool aDisable)
     {
         if (aDisable) {
             if (aContext->IsCairo()) {
                 mSurface = aContext->CurrentSurface();
                 if (!mSurface) {
                   return;
--- a/gfx/thebes/gfxD2DSurface.h
+++ b/gfx/thebes/gfxD2DSurface.h
@@ -9,17 +9,17 @@
 #include "gfxASurface.h"
 #include "nsPoint.h"
 #include "nsRect.h"
 
 #include <windows.h>
 
 struct ID3D10Texture2D;
 
-class THEBES_API gfxD2DSurface : public gfxASurface {
+class gfxD2DSurface : public gfxASurface {
 public:
 
     gfxD2DSurface(HWND wnd,
                   gfxContentType aContent);
 
     gfxD2DSurface(const gfxIntSize& size,
                   gfxImageFormat imageFormat = ImageFormatRGB24);
 
--- a/gfx/thebes/gfxDrawable.h
+++ b/gfx/thebes/gfxDrawable.h
@@ -17,17 +17,17 @@
 class gfxASurface;
 class gfxContext;
 
 /**
  * gfxDrawable
  * An Interface representing something that has an intrinsic size and can draw
  * itself repeatedly.
  */
-class THEBES_API gfxDrawable {
+class gfxDrawable {
     NS_INLINE_DECL_REFCOUNTING(gfxDrawable)
 public:
     gfxDrawable(const gfxIntSize aSize)
      : mSize(aSize) {}
     virtual ~gfxDrawable() {}
 
     /**
      * Draw into aContext filling aFillRect, possibly repeating, using aFilter.
@@ -46,17 +46,17 @@ public:
 protected:
     const gfxIntSize mSize;
 };
 
 /**
  * gfxSurfaceDrawable
  * A convenience implementation of gfxDrawable for surfaces.
  */
-class THEBES_API gfxSurfaceDrawable : public gfxDrawable {
+class gfxSurfaceDrawable : public gfxDrawable {
 public:
     gfxSurfaceDrawable(gfxASurface* aSurface, const gfxIntSize aSize,
                        const gfxMatrix aTransform = gfxMatrix());
     virtual ~gfxSurfaceDrawable() {}
 
     virtual bool Draw(gfxContext* aContext,
                         const gfxRect& aFillRect,
                         bool aRepeat,
@@ -67,17 +67,17 @@ protected:
     nsRefPtr<gfxASurface> mSurface;
     const gfxMatrix mTransform;
 };
 
 /**
  * gfxDrawingCallback
  * A simple drawing functor.
  */
-class THEBES_API gfxDrawingCallback {
+class gfxDrawingCallback {
     NS_INLINE_DECL_REFCOUNTING(gfxDrawingCallback)
 public:
     virtual ~gfxDrawingCallback() {}
 
     /**
      * Draw into aContext filling aFillRect using aFilter.
      * aTransform is a userspace to "image"space matrix. For example, if Draw
      * draws using a gfxPattern, this is the matrix that should be set on the
@@ -90,17 +90,17 @@ public:
                               const gfxMatrix& aTransform = gfxMatrix()) = 0;
 
 };
 
 /**
  * gfxCallbackDrawable
  * A convenience implementation of gfxDrawable for callbacks.
  */
-class THEBES_API gfxCallbackDrawable : public gfxDrawable {
+class gfxCallbackDrawable : public gfxDrawable {
 public:
     gfxCallbackDrawable(gfxDrawingCallback* aCallback, const gfxIntSize aSize);
     virtual ~gfxCallbackDrawable() {}
 
     virtual bool Draw(gfxContext* aContext,
                         const gfxRect& aFillRect,
                         bool aRepeat,
                         const gfxPattern::GraphicsFilter& aFilter,
@@ -112,17 +112,17 @@ protected:
     nsRefPtr<gfxDrawingCallback> mCallback;
     nsRefPtr<gfxSurfaceDrawable> mSurfaceDrawable;
 };
 
 /**
  * gfxPatternDrawable
  * A convenience implementation of gfxDrawable for patterns.
  */
-class THEBES_API gfxPatternDrawable : public gfxDrawable {
+class gfxPatternDrawable : public gfxDrawable {
 public:
     gfxPatternDrawable(gfxPattern* aPattern,
                        const gfxIntSize aSize);
     virtual ~gfxPatternDrawable() {}
 
     virtual bool Draw(gfxContext* aContext,
                         const gfxRect& aFillRect,
                         bool aRepeat,
--- a/gfx/thebes/gfxFT2Fonts.h
+++ b/gfx/thebes/gfxFT2Fonts.h
@@ -85,17 +85,17 @@ protected:
                   gfxShapedText   *aShapedText);
 
     typedef nsBaseHashtableET<nsUint32HashKey, CachedGlyphData> CharGlyphMapEntryType;
     typedef nsTHashtable<CharGlyphMapEntryType> CharGlyphMap;
     CharGlyphMap mCharGlyphCache;
 };
 
 #ifndef ANDROID // not needed on Android, uses the standard gfxFontGroup directly
-class THEBES_API gfxFT2FontGroup : public gfxFontGroup {
+class gfxFT2FontGroup : public gfxFontGroup {
 public: // new functions
     gfxFT2FontGroup (const nsAString& families,
                     const gfxFontStyle *aStyle,
                     gfxUserFontSet *aUserFontSet);
     virtual ~gfxFT2FontGroup ();
 
 protected: // from gfxFontGroup
 
--- a/gfx/thebes/gfxFont.h
+++ b/gfx/thebes/gfxFont.h
@@ -54,17 +54,17 @@ class nsILanguageAtomService;
 
 #define FONT_MAX_SIZE                  2000.0
 
 #define NO_FONT_LANGUAGE_OVERRIDE      0
 
 struct FontListSizes;
 struct gfxTextRunDrawCallbacks;
 
-struct THEBES_API gfxFontStyle {
+struct gfxFontStyle {
     gfxFontStyle();
     gfxFontStyle(uint8_t aStyle, uint16_t aWeight, int16_t aStretch,
                  gfxFloat aSize, nsIAtom *aLanguage,
                  float aSizeAdjust, bool aSystemFont,
                  bool aPrinterFont,
                  const nsString& aLanguageOverride);
     gfxFontStyle(const gfxFontStyle& aStyle);
 
@@ -891,17 +891,17 @@ struct FontCacheSizes {
     FontCacheSizes()
         : mFontInstances(0), mShapedWords(0)
     { }
 
     size_t mFontInstances; // memory used by instances of gfxFont subclasses
     size_t mShapedWords; // memory used by the per-font shapedWord caches
 };
 
-class THEBES_API gfxFontCache MOZ_FINAL : public nsExpirationTracker<gfxFont,3> {
+class gfxFontCache MOZ_FINAL : public nsExpirationTracker<gfxFont,3> {
 public:
     enum {
         FONT_TIMEOUT_SECONDS = 10,
         SHAPED_WORD_TIMEOUT_SECONDS = 60
     };
 
     gfxFontCache();
     ~gfxFontCache();
@@ -1002,17 +1002,17 @@ protected:
     nsTHashtable<HashEntry> mFonts;
 
     static PLDHashOperator ClearCachedWordsForFont(HashEntry* aHashEntry, void*);
     static PLDHashOperator AgeCachedWordsForFont(HashEntry* aHashEntry, void*);
     static void WordCacheExpirationTimerCallback(nsITimer* aTimer, void* aCache);
     nsCOMPtr<nsITimer>      mWordCacheExpirationTimer;
 };
 
-class THEBES_API gfxTextRunFactory {
+class gfxTextRunFactory {
     NS_INLINE_DECL_REFCOUNTING(gfxTextRunFactory)
 
 public:
     // Flags in the mask 0xFFFF0000 are reserved for textrun clients
     // Flags in the mask 0x0000F000 are reserved for per-platform fonts
     // Flags in the mask 0x00000FFF are set by the textrun creator.
     enum {
         CACHE_TEXT_FLAGS    = 0xF0000000,
@@ -1124,17 +1124,17 @@ public:
  * We store a hashtable from glyph IDs to float bounding rects. For the
  * common case where the glyph has no horizontal left bearing, and no
  * y overflow above the font ascent or below the font descent, and tight
  * bounding boxes are not required, we avoid storing the glyph ID in the hashtable
  * and instead consult an array of 16-bit glyph XMost values (in appunits).
  * This array always has an entry for the font's space glyph --- the width is
  * assumed to be zero.
  */
-class THEBES_API gfxGlyphExtents {
+class gfxGlyphExtents {
 public:
     gfxGlyphExtents(int32_t aAppUnitsPerDevUnit) :
         mAppUnitsPerDevUnit(aAppUnitsPerDevUnit) {
         MOZ_COUNT_CTOR(gfxGlyphExtents);
         mTightGlyphExtents.Init();
     }
     ~gfxGlyphExtents();
 
@@ -1282,17 +1282,17 @@ public:
                       nsDataHashtable<nsUint32HashKey,uint32_t>& aMergedFeatures);
 
 protected:
     // the font this shaper is working with
     gfxFont * mFont;
 };
 
 /* a SPECIFIC single font family */
-class THEBES_API gfxFont {
+class gfxFont {
 public:
     nsrefcnt AddRef(void) {
         NS_PRECONDITION(int32_t(mRefCnt) >= 0, "illegal refcnt");
         if (mExpirationState.IsTracked()) {
             gfxFontCache::GetCache()->RemoveObject(this);
         }
         ++mRefCnt;
         NS_LOG_ADDREF(this, mRefCnt, "gfxFont", sizeof(*this));
@@ -1489,17 +1489,17 @@ public:
      */
     struct Spacing {
         gfxFloat mBefore;
         gfxFloat mAfter;
     };
     /**
      * Metrics for a particular string
      */
-    struct THEBES_API RunMetrics {
+    struct RunMetrics {
         RunMetrics() {
             mAdvanceWidth = mAscent = mDescent = 0.0;
         }
 
         void CombineWith(const RunMetrics& aOther, bool aOtherIsOnLeft);
 
         // can be negative (partly due to negative spacing).
         // Advance widths should be additive: the advance width of the
@@ -2641,17 +2641,17 @@ struct gfxTextRunDrawCallbacks {
  * persistently (insofar as they affect the shaping of glyphs; gfxTextRun does
  * not actually do anything to explicitly account for line breaks). Initially
  * there are no line breaks. The textrun can record line breaks before or after
  * any given cluster. (Line breaks specified inside clusters are ignored.)
  * 
  * It is important that zero-length substrings are handled correctly. This will
  * be on the test!
  */
-class THEBES_API gfxTextRun : public gfxShapedText {
+class gfxTextRun : public gfxShapedText {
 public:
 
     // Override operator delete to properly free the object that was
     // allocated via moz_malloc.
     void operator delete(void* p) {
         moz_free(p);
     }
 
@@ -2963,17 +2963,17 @@ public:
 
     // The text is divided into GlyphRuns as necessary
     struct GlyphRun {
         nsRefPtr<gfxFont> mFont;   // never null
         uint32_t          mCharacterOffset; // into original UTF16 string
         uint8_t           mMatchType;
     };
 
-    class THEBES_API GlyphRunIterator {
+    class GlyphRunIterator {
     public:
         GlyphRunIterator(gfxTextRun *aTextRun, uint32_t aStart, uint32_t aLength)
           : mTextRun(aTextRun), mStartOffset(aStart), mEndOffset(aStart + aLength) {
             mNextIndex = mTextRun->FindFirstGlyphRunContaining(aStart);
         }
         bool NextRun();
         GlyphRun *GetGlyphRun() { return mGlyphRun; }
         uint32_t GetStringStart() { return mStringStart; }
@@ -3249,17 +3249,17 @@ private:
 
     bool              mSkipDrawing; // true if the font group we used had a user font
                                     // download that's in progress, so we should hide text
                                     // until the download completes (or timeout fires)
     bool              mReleasedFontGroup; // we already called NS_RELEASE on
                                           // mFontGroup, so don't do it again
 };
 
-class THEBES_API gfxFontGroup : public gfxTextRunFactory {
+class gfxFontGroup : public gfxTextRunFactory {
 public:
     class FamilyFace {
     public:
         FamilyFace() { }
 
         FamilyFace(gfxFontFamily* aFamily, gfxFont* aFont)
             : mFamily(aFamily), mFont(aFont)
         {
--- a/gfx/thebes/gfxFontFeatures.h
+++ b/gfx/thebes/gfxFontFeatures.h
@@ -44,17 +44,17 @@ operator<(const gfxAlternateValue& a, co
 }
 
 inline bool
 operator==(const gfxAlternateValue& a, const gfxAlternateValue& b)
 {
     return (a.alternate == b.alternate) && (a.value == b.value);
 }
 
-class THEBES_API gfxFontFeatureValueSet {
+class gfxFontFeatureValueSet {
 public:
     NS_INLINE_DECL_REFCOUNTING(gfxFontFeatureValueSet)
 
     gfxFontFeatureValueSet();
     virtual ~gfxFontFeatureValueSet() {}
 
     struct ValueList {
         ValueList(const nsAString& aName, const nsTArray<uint32_t>& aSelectors)
--- a/gfx/thebes/gfxFontMissingGlyphs.h
+++ b/gfx/thebes/gfxFontMissingGlyphs.h
@@ -9,17 +9,17 @@
 #include "gfxTypes.h"
 #include "gfxContext.h"
 #include "gfxRect.h"
 
 /**
  * This class should not be instantiated. It's just a container
  * for some helper functions.
  */
-class THEBES_API gfxFontMissingGlyphs {
+class gfxFontMissingGlyphs {
 public:
     /**
      * Draw hexboxes for a missing glyph.
      * @param aContext the context to draw to
      * @param aRect the glyph-box for the glyph that is missing
      * @param aChar the UTF16 codepoint for the character
      * @param aAppUnitsPerDevPixel the appUnits to devPixel ratio we're using,
      *                             (so we can scale glyphs to a sensible size)
--- a/gfx/thebes/gfxFontTest.h
+++ b/gfx/thebes/gfxFontTest.h
@@ -9,17 +9,17 @@
 #include "nsString.h"
 #include "nsTArray.h"
 
 #include "cairo.h"
 
 #include "gfxFont.h"
 #include "gfxUserFontSet.h"
 
-struct THEBES_API gfxFontTestItem {
+struct gfxFontTestItem {
     gfxFontTestItem(const nsCString& fontName,
                     cairo_glyph_t *cglyphs, int nglyphs)
         : platformFont(fontName)
     {
         glyphs = new cairo_glyph_t[nglyphs];
         memcpy (glyphs, cglyphs, sizeof(cairo_glyph_t) * nglyphs);
         num_glyphs = nglyphs;
     }
@@ -36,17 +36,17 @@ struct THEBES_API gfxFontTestItem {
     }
 
     nsCString platformFont;
     cairo_glyph_t *glyphs;
     int num_glyphs;
 };
 
 
-class THEBES_API gfxFontTestStore {
+class gfxFontTestStore {
 public:
     gfxFontTestStore() { }
 
     void AddItem (const nsCString& fontString,
                   cairo_glyph_t *cglyphs, int nglyphs)
     {
         items.AppendElement(gfxFontTestItem(fontString, cglyphs, nglyphs));
     }
--- a/gfx/thebes/gfxFontUtils.h
+++ b/gfx/thebes/gfxFontUtils.h
@@ -644,17 +644,17 @@ struct FontDataOverlay {
     
 enum gfxUserFontType {
     GFX_USERFONT_UNKNOWN = 0,
     GFX_USERFONT_OPENTYPE = 1,
     GFX_USERFONT_SVG = 2,
     GFX_USERFONT_WOFF = 3
 };
 
-class THEBES_API gfxFontUtils {
+class gfxFontUtils {
 
 public:
     // these are public because gfxFont.cpp also looks into the name table
     enum {
         NAME_ID_FAMILY = 1,
         NAME_ID_STYLE = 2,
         NAME_ID_UNIQUE = 3,
         NAME_ID_FULL = 4,
--- a/gfx/thebes/gfxGdkNativeRenderer.h
+++ b/gfx/thebes/gfxGdkNativeRenderer.h
@@ -16,17 +16,17 @@ class gfxASurface;
 class gfxContext;
 
 /**
  * This class lets us take code that draws into an GDK drawable and lets us
  * use it to draw into any Thebes context. The user should subclass this class,
  * override DrawWithGDK, and then call Draw(). The drawing will be subjected
  * to all Thebes transformations, clipping etc.
  */
-class THEBES_API gfxGdkNativeRenderer
+class gfxGdkNativeRenderer
 #ifdef MOZ_X11
     : private gfxXlibNativeRenderer
 #endif
 {
 public:
     /**
      * Perform the native drawing.
      * @param offsetX draw at this offset into the given drawable
--- a/gfx/thebes/gfxImageSurface.h
+++ b/gfx/thebes/gfxImageSurface.h
@@ -19,17 +19,17 @@ class SourceSurface;
 }
 }
 
 /**
  * A raw image buffer. The format can be set in the constructor. Its main
  * purpose is for storing read-only images and using it as a source surface,
  * but it can also be drawn to.
  */
-class THEBES_API gfxImageSurface : public gfxASurface {
+class gfxImageSurface : public gfxASurface {
 public:
     /**
      * Construct an image surface around an existing buffer of image data.
      * @param aData A buffer containing the image data
      * @param aSize The size of the buffer
      * @param aStride The stride of the buffer
      * @param format Format of the data
      *
@@ -138,17 +138,17 @@ protected:
 
     gfxIntSize mSize;
     bool mOwnsData;
     unsigned char *mData;
     gfxImageFormat mFormat;
     long mStride;
 };
 
-class THEBES_API gfxSubimageSurface : public gfxImageSurface {
+class gfxSubimageSurface : public gfxImageSurface {
 protected:
     friend class gfxImageSurface;
     gfxSubimageSurface(gfxImageSurface* aParent,
                        unsigned char* aData,
                        const gfxIntSize& aSize);
 private:
     nsRefPtr<gfxImageSurface> mParent;
 };
--- a/gfx/thebes/gfxLineSegment.h
+++ b/gfx/thebes/gfxLineSegment.h
@@ -4,17 +4,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef GFX_LINESEGMENT_H
 #define GFX_LINESEGMENT_H
 
 #include "gfxTypes.h"
 #include "gfxPoint.h"
 
-struct THEBES_API gfxLineSegment {
+struct gfxLineSegment {
   gfxLineSegment(const gfxPoint &aStart, const gfxPoint &aEnd) 
     : mStart(aStart)
     , mEnd(aEnd)
   {}
 
   bool PointsOnSameSide(const gfxPoint& aOne, const gfxPoint& aTwo)
   {
     // Solve the equation y - mStart.y - ((mEnd.y - mStart.y)/(mEnd.x - mStart.x))(x - mStart.x) for both points 
--- a/gfx/thebes/gfxMatrix.h
+++ b/gfx/thebes/gfxMatrix.h
@@ -26,17 +26,17 @@
  *
  * So, transforming a point (x, y) results in:
  *
  *           / a  b  0 \   / a * x + c * y + tx \ T
  * (x y 1) * | c  d  0 | = | b * x + d * y + ty |
  *           \ tx ty 1 /   \         1          /
  *
  */
-struct THEBES_API gfxMatrix {
+struct gfxMatrix {
     double xx; double yx;
     double xy; double yy;
     double x0; double y0;
 
 public:
     /**
      * Initializes this matrix as the identity matrix.
      */
--- a/gfx/thebes/gfxOS2Fonts.h
+++ b/gfx/thebes/gfxOS2Fonts.h
@@ -54,17 +54,17 @@ private:
     Metrics *mMetrics;
     gfxFloat mAdjustedSize;
     uint32_t mSpaceGlyph;
     int mHinting;
     bool mAntialias;
 };
 
 
-class THEBES_API gfxOS2FontGroup : public gfxFontGroup {
+class gfxOS2FontGroup : public gfxFontGroup {
 public:
     gfxOS2FontGroup(const nsAString& aFamilies, const gfxFontStyle* aStyle, gfxUserFontSet *aUserFontSet);
     virtual ~gfxOS2FontGroup();
 
     virtual gfxFontGroup *Copy(const gfxFontStyle *aStyle);
 
     // create and initialize the textRun using FreeType font
     virtual gfxTextRun *MakeTextRun(const PRUnichar* aString, uint32_t aLength,
--- a/gfx/thebes/gfxOS2Platform.h
+++ b/gfx/thebes/gfxOS2Platform.h
@@ -11,17 +11,17 @@
 
 #include "gfxPlatform.h"
 #include "gfxOS2Fonts.h"
 #include "gfxFontUtils.h"
 #include "nsTArray.h"
 
 class gfxFontconfigUtils;
 
-class THEBES_API gfxOS2Platform : public gfxPlatform {
+class gfxOS2Platform : public gfxPlatform {
 
 public:
     gfxOS2Platform();
     virtual ~gfxOS2Platform();
 
     static gfxOS2Platform *GetPlatform() {
         return (gfxOS2Platform*) gfxPlatform::GetPlatform();
     }
--- a/gfx/thebes/gfxOS2Surface.h
+++ b/gfx/thebes/gfxOS2Surface.h
@@ -7,17 +7,17 @@
 #define GFX_OS2_SURFACE_H
 
 #include "gfxASurface.h"
 
 #define INCL_GPIBITMAPS
 #include <os2.h>
 #include <cairo-os2.h>
 
-class THEBES_API gfxOS2Surface : public gfxASurface {
+class gfxOS2Surface : public gfxASurface {
 
 public:
     // constructor used to create a memory surface of given size
     gfxOS2Surface(const gfxIntSize& aSize,
                   gfxASurface::gfxImageFormat aImageFormat);
     // constructor for surface connected to an onscreen window
     gfxOS2Surface(HWND aWnd);
     // constructor for surface connected to a printing device context
--- a/gfx/thebes/gfxPDFSurface.h
+++ b/gfx/thebes/gfxPDFSurface.h
@@ -8,17 +8,17 @@
 
 #include "gfxASurface.h"
 #include "gfxContext.h"
 
 /* for the output stream */
 #include "nsCOMPtr.h"
 #include "nsIOutputStream.h"
 
-class THEBES_API gfxPDFSurface : public gfxASurface {
+class gfxPDFSurface : public gfxASurface {
 public:
     gfxPDFSurface(nsIOutputStream *aStream, const gfxSize& aSizeInPoints);
     virtual ~gfxPDFSurface();
 
     virtual nsresult BeginPrinting(const nsAString& aTitle, const nsAString& aPrintToFileName);
     virtual nsresult EndPrinting();
     virtual nsresult AbortPrinting();
     virtual nsresult BeginPage();
--- a/gfx/thebes/gfxPSSurface.h
+++ b/gfx/thebes/gfxPSSurface.h
@@ -8,17 +8,17 @@
 
 #include "gfxASurface.h"
 
 /* for the output stream */
 #include "nsCOMPtr.h"
 #include "nsIOutputStream.h"
 #include "gfxContext.h"
 
-class THEBES_API gfxPSSurface : public gfxASurface {
+class gfxPSSurface : public gfxASurface {
 public:
     enum PageOrientation {
         PORTRAIT,
         LANDSCAPE
     };
 
     gfxPSSurface(nsIOutputStream *aStream, const gfxSize& aSizeInPoints, PageOrientation aOrientation);
     virtual ~gfxPSSurface();
--- a/gfx/thebes/gfxPangoFonts.h
+++ b/gfx/thebes/gfxPangoFonts.h
@@ -17,17 +17,17 @@
 
 class gfxFcFontSet;
 class gfxFcFont;
 class gfxProxyFontEntry;
 typedef struct _FcPattern FcPattern;
 typedef struct FT_FaceRec_* FT_Face;
 typedef struct FT_LibraryRec_  *FT_Library;
 
-class THEBES_API gfxPangoFontGroup : public gfxFontGroup {
+class gfxPangoFontGroup : public gfxFontGroup {
 public:
     gfxPangoFontGroup (const nsAString& families,
                        const gfxFontStyle *aStyle,
                        gfxUserFontSet *aUserFontSet);
     virtual ~gfxPangoFontGroup ();
 
     virtual gfxFontGroup *Copy(const gfxFontStyle *aStyle);
 
--- a/gfx/thebes/gfxPath.h
+++ b/gfx/thebes/gfxPath.h
@@ -12,17 +12,17 @@
 class gfxContext;
 struct gfxPoint;
 typedef struct cairo_path cairo_path_t;
 
 /**
  * Class representing a path. Can be created by copying the current path
  * of a gfxContext.
  */
-class THEBES_API gfxPath {
+class gfxPath {
     NS_INLINE_DECL_REFCOUNTING(gfxPath)
 
     friend class gfxContext;
 
 protected:
     gfxPath(cairo_path_t* aPath);
 
 public:
@@ -31,17 +31,17 @@ public:
 protected:
     cairo_path_t* mPath;
 };
 
 /**
  * Specialization of a path that only contains linear pieces. Can be created
  * from the existing path of a gfxContext.
  */
-class THEBES_API gfxFlattenedPath : public gfxPath {
+class gfxFlattenedPath : public gfxPath {
     friend class gfxContext;
 
 protected:
     gfxFlattenedPath(cairo_path_t* aPath);
 
 public:
     virtual ~gfxFlattenedPath();
 
--- a/gfx/thebes/gfxPattern.h
+++ b/gfx/thebes/gfxPattern.h
@@ -15,17 +15,17 @@
 #include "mozilla/gfx/2D.h"
 #include "mozilla/Util.h"
 
 class gfxContext;
 class gfxASurface;
 typedef struct _cairo_pattern cairo_pattern_t;
 
 
-class THEBES_API gfxPattern {
+class gfxPattern {
     NS_INLINE_DECL_REFCOUNTING(gfxPattern)
 
 public:
     gfxPattern(cairo_pattern_t *aPattern);
     gfxPattern(const gfxRGBA& aColor);
     gfxPattern(gfxASurface *surface); // from another surface
     // linear
     gfxPattern(gfxFloat x0, gfxFloat y0, gfxFloat x1, gfxFloat y1); // linear
--- a/gfx/thebes/gfxPlatform.h
+++ b/gfx/thebes/gfxPlatform.h
@@ -134,17 +134,17 @@ GetBackendName(mozilla::gfx::BackendType
       case mozilla::gfx::BACKEND_RECORDING:
         return "recording";
       case mozilla::gfx::BACKEND_NONE:
         return "none";
   }
   MOZ_NOT_REACHED("Incomplete switch");
 }
 
-class THEBES_API gfxPlatform {
+class gfxPlatform {
 public:
     /**
      * Return a pointer to the current active platform.
      * This is a singleton; it contains mostly convenience
      * functions to obtain platform-specific objects.
      */
     static gfxPlatform *GetPlatform();
 
--- a/gfx/thebes/gfxPlatformGtk.h
+++ b/gfx/thebes/gfxPlatformGtk.h
@@ -18,17 +18,17 @@ extern "C" {
 
 class gfxFontconfigUtils;
 #ifndef MOZ_PANGO
 class FontFamily;
 class FontEntry;
 typedef struct FT_LibraryRec_ *FT_Library;
 #endif
 
-class THEBES_API gfxPlatformGtk : public gfxPlatform {
+class gfxPlatformGtk : public gfxPlatform {
 public:
     gfxPlatformGtk();
     virtual ~gfxPlatformGtk();
 
     static gfxPlatformGtk *GetPlatform() {
         return (gfxPlatformGtk*) gfxPlatform::GetPlatform();
     }
 
--- a/gfx/thebes/gfxPlatformMac.h
+++ b/gfx/thebes/gfxPlatformMac.h
@@ -16,17 +16,17 @@
 
 #define MAC_OS_X_MAJOR_VERSION_MASK 0xFFFFFFF0U
 
 class gfxTextRun;
 class gfxFontFamily;
 
 namespace mozilla { namespace gfx { class DrawTarget; }}
 
-class THEBES_API gfxPlatformMac : public gfxPlatform {
+class gfxPlatformMac : public gfxPlatform {
 public:
     gfxPlatformMac();
     virtual ~gfxPlatformMac();
 
     static gfxPlatformMac *GetPlatform() {
         return (gfxPlatformMac*) gfxPlatform::GetPlatform();
     }
 
--- a/gfx/thebes/gfxPoint.h
+++ b/gfx/thebes/gfxPoint.h
@@ -11,25 +11,25 @@
 #include "mozilla/gfx/BasePoint.h"
 #include "nsSize.h"
 #include "nsPoint.h"
 
 #include "gfxTypes.h"
 
 typedef nsIntSize gfxIntSize;
 
-struct THEBES_API gfxSize : public mozilla::gfx::BaseSize<gfxFloat, gfxSize> {
+struct gfxSize : public mozilla::gfx::BaseSize<gfxFloat, gfxSize> {
     typedef mozilla::gfx::BaseSize<gfxFloat, gfxSize> Super;
 
     gfxSize() : Super() {}
     gfxSize(gfxFloat aWidth, gfxFloat aHeight) : Super(aWidth, aHeight) {}
     gfxSize(const nsIntSize& aSize) : Super(aSize.width, aSize.height) {}
 };
 
-struct THEBES_API gfxPoint : public mozilla::gfx::BasePoint<gfxFloat, gfxPoint> {
+struct gfxPoint : public mozilla::gfx::BasePoint<gfxFloat, gfxPoint> {
     typedef mozilla::gfx::BasePoint<gfxFloat, gfxPoint> Super;
 
     gfxPoint() : Super() {}
     gfxPoint(gfxFloat aX, gfxFloat aY) : Super(aX, aY) {}
     gfxPoint(const nsIntPoint& aPoint) : Super(aPoint.x, aPoint.y) {}
 
     // Round() is *not* rounding to nearest integer if the values are negative.
     // They are always rounding as floor(n + 0.5).
--- a/gfx/thebes/gfxPoint3D.h
+++ b/gfx/thebes/gfxPoint3D.h
@@ -4,16 +4,16 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef GFX_POINT3D_H
 #define GFX_POINT3D_H
 
 #include "mozilla/gfx/BasePoint3D.h"
 #include "gfxTypes.h"
 
-struct THEBES_API gfxPoint3D : public mozilla::gfx::BasePoint3D<gfxFloat, gfxPoint3D> {
+struct gfxPoint3D : public mozilla::gfx::BasePoint3D<gfxFloat, gfxPoint3D> {
     typedef mozilla::gfx::BasePoint3D<gfxFloat, gfxPoint3D> Super;
 
     gfxPoint3D() : Super() {}
     gfxPoint3D(gfxFloat aX, gfxFloat aY, gfxFloat aZ) : Super(aX, aY, aZ) {}
 };
 
 #endif /* GFX_POINT3D_H */ 
--- a/gfx/thebes/gfxPointH3D.h
+++ b/gfx/thebes/gfxPointH3D.h
@@ -4,16 +4,16 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef GFX_POINTH3D_H
 #define GFX_POINTH3D_H
 
 #include "mozilla/gfx/BasePoint4D.h"
 #include "gfxTypes.h"
 
-struct THEBES_API gfxPointH3D : public mozilla::gfx::BasePoint4D<float, gfxPointH3D> {
+struct gfxPointH3D : public mozilla::gfx::BasePoint4D<float, gfxPointH3D> {
     typedef mozilla::gfx::BasePoint4D<float, gfxPointH3D> Super;
 
     gfxPointH3D() : Super() {}
     gfxPointH3D(float aX, float aY, float aZ, float aW) : Super(aX, aY, aZ, aW) {}
 };
 
 #endif /* GFX_POINTH3D_H */
--- a/gfx/thebes/gfxQPainterSurface.h
+++ b/gfx/thebes/gfxQPainterSurface.h
@@ -10,17 +10,17 @@
 #include "gfxImageSurface.h"
 
 #include "cairo-features.h"
 #ifdef CAIRO_HAS_QT_SURFACE
 
 class QPainter;
 class QImage;
 
-class THEBES_API gfxQPainterSurface : public gfxASurface {
+class gfxQPainterSurface : public gfxASurface {
 public:
     gfxQPainterSurface(QPainter *painter);
     gfxQPainterSurface(const gfxIntSize& size, gfxImageFormat format);
     gfxQPainterSurface(const gfxIntSize& size, gfxContentType content);
 
     gfxQPainterSurface(cairo_surface_t *csurf);
 
     virtual ~gfxQPainterSurface();
--- a/gfx/thebes/gfxQtNativeRenderer.h
+++ b/gfx/thebes/gfxQtNativeRenderer.h
@@ -15,17 +15,17 @@
 class QRect;
 
 /**
  * This class lets us take code that draws into an Xlib surface drawable and lets us
  * use it to draw into any Thebes context. The user should subclass this class,
  * override NativeDraw, and then call Draw(). The drawing will be subjected
  * to all Thebes transformations, clipping etc.
  */
-class THEBES_API gfxQtNativeRenderer {
+class gfxQtNativeRenderer {
 public:
     /**
      * Perform the native drawing.
      * @param offsetX draw at this offset into the given drawable
      * @param offsetY draw at this offset into the given drawable
      * @param clipRects an array of rects; clip to the union
      * @param numClipRects the number of rects in the array, or zero if
      * no clipping is required
--- a/gfx/thebes/gfxQtPlatform.h
+++ b/gfx/thebes/gfxQtPlatform.h
@@ -18,17 +18,17 @@ class gfxFontconfigUtils;
 class QWidget;
 #ifndef MOZ_PANGO
 typedef struct FT_LibraryRec_ *FT_Library;
 
 class FontFamily;
 class FontEntry;
 #endif
 
-class THEBES_API gfxQtPlatform : public gfxPlatform {
+class gfxQtPlatform : public gfxPlatform {
 public:
 
     enum RenderMode {
         /* Use QPainter surfaces */
         RENDER_QPAINTER = 0,
         /* Use offscreen buffer for rendering with image or xlib gfx backend */
         RENDER_BUFFERED,
         /* Direct rendering to Widget surface */
--- a/gfx/thebes/gfxQuad.h
+++ b/gfx/thebes/gfxQuad.h
@@ -5,17 +5,17 @@
 
 #ifndef GFX_QUAD_H
 #define GFX_QUAD_H
 
 #include "gfxTypes.h"
 #include "gfxLineSegment.h"
 #include <algorithm>
 
-struct THEBES_API gfxQuad {
+struct gfxQuad {
     gfxQuad(const gfxPoint& aOne, const gfxPoint& aTwo, const gfxPoint& aThree, const gfxPoint& aFour)
     {
         mPoints[0] = aOne;
         mPoints[1] = aTwo;
         mPoints[2] = aThree;
         mPoints[3] = aFour;
     }
 
--- a/gfx/thebes/gfxQuartzImageSurface.h
+++ b/gfx/thebes/gfxQuartzImageSurface.h
@@ -4,17 +4,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef GFX_QUARTZIMAGESURFACE_H
 #define GFX_QUARTZIMAGESURFACE_H
 
 #include "gfxASurface.h"
 #include "gfxImageSurface.h"
 
-class THEBES_API gfxQuartzImageSurface : public gfxASurface {
+class gfxQuartzImageSurface : public gfxASurface {
 public:
     gfxQuartzImageSurface(gfxImageSurface *imageSurface);
     gfxQuartzImageSurface(cairo_surface_t *csurf);
 
     virtual ~gfxQuartzImageSurface();
 
     already_AddRefed<gfxImageSurface> GetAsImageSurface();
     virtual int32_t KnownMemoryUsed();
--- a/gfx/thebes/gfxQuartzNativeDrawing.h
+++ b/gfx/thebes/gfxQuartzNativeDrawing.h
@@ -6,17 +6,17 @@
 #ifndef _GFXQUARTZNATIVEDRAWING_H_
 #define _GFXQUARTZNATIVEDRAWING_H_
 
 #include "mozilla/Attributes.h"
 
 #include "gfxContext.h"
 #include "gfxQuartzSurface.h"
 
-class THEBES_API gfxQuartzNativeDrawing {
+class gfxQuartzNativeDrawing {
 public:
 
     /* Create native Quartz drawing for a rectangle bounded by
      * nativeRect.
      *
      * Typical usage looks like:
      *
      *   gfxQuartzNativeDrawing nativeDraw(ctx, nativeRect);
--- a/gfx/thebes/gfxQuartzSurface.h
+++ b/gfx/thebes/gfxQuartzSurface.h
@@ -8,17 +8,17 @@
 
 #include "gfxASurface.h"
 #include "gfxImageSurface.h"
 
 #include <Carbon/Carbon.h>
 
 class gfxContext;
 
-class THEBES_API gfxQuartzSurface : public gfxASurface {
+class gfxQuartzSurface : public gfxASurface {
 public:
     gfxQuartzSurface(const gfxSize& size, gfxImageFormat format, bool aForPrinting = false);
     gfxQuartzSurface(CGContextRef context, const gfxSize& size, bool aForPrinting = false);
     gfxQuartzSurface(CGContextRef context, const gfxIntSize& size, bool aForPrinting = false);
     gfxQuartzSurface(cairo_surface_t *csurf, bool aForPrinting = false);
     gfxQuartzSurface(unsigned char *data, const gfxSize& size, long stride, gfxImageFormat format, bool aForPrinting = false);
     gfxQuartzSurface(unsigned char *data, const gfxIntSize& size, long stride, gfxImageFormat format, bool aForPrinting = false);
 
--- a/gfx/thebes/gfxQuaternion.h
+++ b/gfx/thebes/gfxQuaternion.h
@@ -6,17 +6,17 @@
 #ifndef GFX_QUATERNION_H
 #define GFX_QUATERNION_H
 
 #include "mozilla/gfx/BasePoint4D.h"
 #include "gfx3DMatrix.h"
 #include "nsAlgorithm.h"
 #include <algorithm>
 
-struct THEBES_API gfxQuaternion : public mozilla::gfx::BasePoint4D<gfxFloat, gfxQuaternion> {
+struct gfxQuaternion : public mozilla::gfx::BasePoint4D<gfxFloat, gfxQuaternion> {
     typedef mozilla::gfx::BasePoint4D<gfxFloat, gfxQuaternion> Super;
 
     gfxQuaternion() : Super() {}
     gfxQuaternion(gfxFloat aX, gfxFloat aY, gfxFloat aZ, gfxFloat aW) : Super(aX, aY, aZ, aW) {}
 
     gfxQuaternion(const gfx3DMatrix& aMatrix) {
         w = 0.5 * sqrt(std::max(1 + aMatrix[0][0] + aMatrix[1][1] + aMatrix[2][2], 0.0f));
         x = 0.5 * sqrt(std::max(1 + aMatrix[0][0] - aMatrix[1][1] - aMatrix[2][2], 0.0f));
--- a/gfx/thebes/gfxRect.h
+++ b/gfx/thebes/gfxRect.h
@@ -51,17 +51,17 @@ namespace mozilla {
 
 static inline mozilla::css::Corner operator++(mozilla::css::Corner& corner, int) {
     NS_PRECONDITION(corner >= NS_CORNER_TOP_LEFT &&
                     corner < NS_NUM_CORNERS, "Out of range corner");
     corner = mozilla::css::Corner(corner + 1);
     return corner;
 }
 
-struct THEBES_API gfxRect :
+struct gfxRect :
     public mozilla::gfx::BaseRect<gfxFloat, gfxRect, gfxPoint, gfxSize, gfxMargin> {
     typedef mozilla::gfx::BaseRect<gfxFloat, gfxRect, gfxPoint, gfxSize, gfxMargin> Super;
 
     gfxRect() : Super() {}
     gfxRect(const gfxPoint& aPos, const gfxSize& aSize) :
         Super(aPos, aSize) {}
     gfxRect(gfxFloat aX, gfxFloat aY, gfxFloat aWidth, gfxFloat aHeight) :
         Super(aX, aY, aWidth, aHeight) {}
@@ -136,17 +136,17 @@ struct THEBES_API gfxRect :
         NS_ASSERTION(k > 0.0, "Invalid (negative) scale factor");
         x /= k;
         y /= k;
         width /= k;
         height /= k;
     }
 };
 
-struct THEBES_API gfxCornerSizes {
+struct gfxCornerSizes {
     gfxSize sizes[NS_NUM_CORNERS];
 
     gfxCornerSizes () { }
 
     gfxCornerSizes (gfxFloat v) {
         for (int i = 0; i < NS_NUM_CORNERS; i++)
             sizes[i].SizeTo(v, v);
     }
--- a/gfx/thebes/gfxSkipChars.h
+++ b/gfx/thebes/gfxSkipChars.h
@@ -30,17 +30,17 @@
  * mBuffer is an array of bytes; even numbered bytes represent characters kept,
  * odd numbered bytes represent characters skipped. After those characters
  * are accounted for, we have mRunCharCount characters which are kept or
  * skipped depending on the value of mRunSkipped.
  * 
  * mCharCount is the sum of counts of all skipped and kept characters, i.e.,
  * the length of the original string.
  */
-class THEBES_API gfxSkipCharsBuilder {
+class gfxSkipCharsBuilder {
 public:
     gfxSkipCharsBuilder() :
         mCharCount(0), mRunCharCount(0), mRunSkipped(false), mInErrorState(false)
     {}
   
     void SkipChars(uint32_t aChars) {
         DoChars(aChars, true);
     }
@@ -88,17 +88,17 @@ private:
 /**
  * The gfxSkipChars list is represented as a list of bytes of the form
  * [chars to keep, chars to skip, chars to keep, chars to skip, ...]
  * In the special case where all chars are to be kept, the list is length
  * zero.
  * 
  * A freshly-created gfxSkipChars means "all chars kept".
  */
-class THEBES_API gfxSkipChars {
+class gfxSkipChars {
 public:
     gfxSkipChars() : mListLength(0), mCharCount(0) {}
   
     void TakeFrom(gfxSkipChars* aSkipChars) {
         mList = aSkipChars->mList.forget();
         mListLength = aSkipChars->mListLength;
         mCharCount = aSkipChars->mCharCount;
         aSkipChars->mCharCount = 0;
@@ -175,17 +175,17 @@ private:
  * always constrained to be >= 0 and <= the string length. When the position
  * is equal to the string length, it is at the end of the string. The current
  * positions do not include any aOriginalStringToSkipCharsOffset.
  * 
  * When the position in the original string corresponds to a skipped character,
  * the skipped-characters offset is the offset of the next unskipped character,
  * or the skipped-characters string length if there is no next unskipped character.
  */
-class THEBES_API gfxSkipCharsIterator {
+class gfxSkipCharsIterator {
 public:
     /**
      * @param aOriginalStringToSkipCharsOffset add this to all incoming and
      * outgoing original string offsets
      */
     gfxSkipCharsIterator(const gfxSkipChars& aSkipChars,
                          int32_t aOriginalStringToSkipCharsOffset,
                          int32_t aOriginalStringOffset)
--- a/gfx/thebes/gfxTeeSurface.h
+++ b/gfx/thebes/gfxTeeSurface.h
@@ -13,17 +13,17 @@
  * Wraps a cairo_tee_surface. The first surface in the surface list is the
  * primary surface, which answers all surface queries (including size).
  * All drawing is performed on all the surfaces.
  *
  * The device transform of a tee surface is applied before drawing to the
  * underlying surfaces --- which also applies the device transforms of the
  * underlying surfaces.
  */
-class THEBES_API gfxTeeSurface : public gfxASurface {
+class gfxTeeSurface : public gfxASurface {
 public:
     gfxTeeSurface(cairo_surface_t *csurf);
     gfxTeeSurface(gfxASurface **aSurfaces, int32_t aSurfaceCount);
 
     virtual const gfxIntSize GetSize() const;
 
     /**
      * Returns the list of underlying surfaces.
--- a/gfx/thebes/gfxTypes.h
+++ b/gfx/thebes/gfxTypes.h
@@ -9,18 +9,16 @@
 #include "nsAtomicRefcnt.h"
 
 /**
  * Currently needs to be 'double' for Cairo compatibility. Could
  * become 'float', perhaps, in some configurations.
  */
 typedef double gfxFloat;
 
-# define THEBES_API
-
 /**
  * Priority of a line break opportunity.
  *
  * eNoBreak       The line has no break opportunities
  * eWordWrapBreak The line has a break opportunity only within a word. With
  *                word-wrap: break-word we will break at this point only if
  *                there are no other break opportunities in the line.
  * eNormalBreak   The line has a break opportunity determined by the standard
--- a/gfx/thebes/gfxUserFontSet.h
+++ b/gfx/thebes/gfxUserFontSet.h
@@ -129,17 +129,17 @@ public:
                 return false;
         }
         return true;
     }
 };
 
 class gfxProxyFontEntry;
 
-class THEBES_API gfxUserFontSet {
+class gfxUserFontSet {
 
 public:
 
     NS_INLINE_DECL_REFCOUNTING(gfxUserFontSet)
 
     gfxUserFontSet();
     virtual ~gfxUserFontSet();
 
--- a/gfx/thebes/gfxUtils.h
+++ b/gfx/thebes/gfxUtils.h
@@ -12,17 +12,17 @@
 #include "ImageContainer.h"
 #include "mozilla/gfx/2D.h"
 #include "imgIContainer.h"
 
 class gfxDrawable;
 class nsIntRegion;
 struct nsIntRect;
 
-class THEBES_API gfxUtils {
+class gfxUtils {
 public:
     /*
      * Premultiply or Unpremultiply aSourceSurface, writing the result
      * to aDestSurface or back into aSourceSurface if aDestSurface is null.
      *
      * If aDestSurface is given, it must have identical format, dimensions, and
      * stride as the source.
      *
--- a/gfx/thebes/gfxWindowsNativeDrawing.h
+++ b/gfx/thebes/gfxWindowsNativeDrawing.h
@@ -6,17 +6,17 @@
 #ifndef _GFXWINDOWSNATIVEDRAWING_H_
 #define _GFXWINDOWSNATIVEDRAWING_H_
 
 #include <windows.h>
 
 #include "gfxContext.h"
 #include "gfxWindowsSurface.h"
 
-class THEBES_API gfxWindowsNativeDrawing {
+class gfxWindowsNativeDrawing {
 public:
 
     /* Flags for notifying this class what kind of operations the native
      * drawing supports
      */
 
     enum {
         /* Whether the native drawing can draw to a surface of content COLOR_ALPHA */
--- a/gfx/thebes/gfxWindowsPlatform.h
+++ b/gfx/thebes/gfxWindowsPlatform.h
@@ -97,17 +97,17 @@ struct ClearTypeParameterInfo {
 
     nsString    displayName;  // typically just 'DISPLAY1'
     int32_t     gamma;
     int32_t     pixelStructure;
     int32_t     clearTypeLevel;
     int32_t     enhancedContrast;
 };
 
-class THEBES_API gfxWindowsPlatform : public gfxPlatform {
+class gfxWindowsPlatform : public gfxPlatform {
 public:
     enum TextRenderingMode {
         TEXT_RENDERING_NO_CLEARTYPE,
         TEXT_RENDERING_NORMAL,
         TEXT_RENDERING_GDI_CLASSIC,
         TEXT_RENDERING_COUNT
     };
 
--- a/gfx/thebes/gfxWindowsSurface.h
+++ b/gfx/thebes/gfxWindowsSurface.h
@@ -11,17 +11,17 @@
 
 /* include windows.h for the HWND and HDC definitions that we need. */
 #include <windows.h>
 /* undefine LoadImage because our code uses that name */
 #undef LoadImage
 
 class gfxContext;
 
-class THEBES_API gfxWindowsSurface : public gfxASurface {
+class gfxWindowsSurface : public gfxASurface {
 public:
     enum {
         FLAG_TAKE_DC = (1 << 0),
         FLAG_FOR_PRINTING = (1 << 1),
         FLAG_IS_TRANSPARENT = (1 << 2)
     };
 
     gfxWindowsSurface(HWND wnd, uint32_t flags = 0);
--- a/gfx/thebes/gfxXlibNativeRenderer.h
+++ b/gfx/thebes/gfxXlibNativeRenderer.h
@@ -16,17 +16,17 @@ class gfxXlibSurface;
 class gfxContext;
 
 /**
  * This class lets us take code that draws into an X drawable and lets us
  * use it to draw into any Thebes context. The user should subclass this class,
  * override DrawWithXib, and then call Draw(). The drawing will be subjected
  * to all Thebes transformations, clipping etc.
  */
-class THEBES_API gfxXlibNativeRenderer {
+class gfxXlibNativeRenderer {
 public:
     /**
      * Perform the native drawing.
      * @param surface the drawable for drawing.
      *                The extents of this surface do not necessarily cover the
      *                entire rectangle with size provided to Draw().
      * @param offsetX draw at this offset into the given drawable
      * @param offsetY draw at this offset into the given drawable
--- a/gfx/thebes/gfxXlibSurface.h
+++ b/gfx/thebes/gfxXlibSurface.h
@@ -10,17 +10,17 @@
 
 #include <X11/extensions/Xrender.h>
 #include <X11/Xlib.h>
 
 #if defined(GL_PROVIDER_GLX)
 #include "GLXLibrary.h"
 #endif
 
-class THEBES_API gfxXlibSurface : public gfxASurface {
+class gfxXlibSurface : public gfxASurface {
 public:
     // construct a wrapper around the specified drawable with dpy/visual.
     // Will use XGetGeometry to query the window/pixmap size.
     gfxXlibSurface(Display *dpy, Drawable drawable, Visual *visual);
 
     // construct a wrapper around the specified drawable with dpy/visual,
     // and known width/height.
     gfxXlibSurface(Display *dpy, Drawable drawable, Visual *visual, const gfxIntSize& size);
--- a/gfx/thebes/nsSurfaceTexture.h
+++ b/gfx/thebes/nsSurfaceTexture.h
@@ -16,17 +16,17 @@
 
 class gfxASurface;
 
 /**
  * This class is a wrapper around Android's SurfaceTexture class.
  * Usage is pretty much exactly like the Java class, so see
  * the Android documentation for details.
  */
-class THEBES_API nsSurfaceTexture {
+class nsSurfaceTexture {
   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(nsSurfaceTexture)
 
 public:
   static nsSurfaceTexture* Create(GLuint aTexture);
   static nsSurfaceTexture* Find(int id);
 
   // Returns with reasonable certainty whether or not we'll
   // be able to create and use a SurfaceTexture