Bug 877382 - Remove THEBES_API decorator. - r=BenWa
authorJeff Gilbert <jgilbert@mozilla.com>
Wed, 29 May 2013 14:59:24 -0700
changeset 133338 8fed67bc814d173ddba7083a1a6e6669456b7a2e
parent 133337 12f538f501b99d0ff9d63aa2a13cec1d13f3d236
child 133339 06889c22f8c62a153e1ec99ac715acba791aacbe
push id28720
push userjgilbert@mozilla.com
push dateWed, 29 May 2013 23:32:39 +0000
treeherdermozilla-inbound@8fed67bc814d [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersBenWa
bugs877382
milestone24.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
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