Bug 1202430 - remove NS_GFX and related macros; r=jrmuizel
authorNathan Froyd <froydnj@mozilla.com>
Mon, 07 Sep 2015 17:53:36 -0400
changeset 261443 69b07795c5fa8718d7119eb7c0319318edf66d7f
parent 261442 2fd91dc12a4219ac7d7631455774a31483d85cb4
child 261444 5eeb7f51f5bf61486395e05ee650d615d912b5ce
push id29345
push usercbook@mozilla.com
push dateWed, 09 Sep 2015 12:06:02 +0000
treeherdermozilla-central@dd9e40b46959 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjrmuizel
bugs1202430, 648911
milestone43.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 1202430 - remove NS_GFX and related macros; r=jrmuizel NS_GFX last meant something prior to bug 648911, which removed support for non-libxul builds. Now that it's meaningless, let's get rid of it.
gfx/src/DriverCrashGuard.h
gfx/src/X11Util.h
gfx/src/gfxCore.h
gfx/src/gfxCrashReporterUtils.h
gfx/src/moz.build
gfx/src/nsColor.cpp
gfx/src/nsColor.h
gfx/src/nsColorNames.h
gfx/src/nsFont.h
gfx/src/nsMargin.h
gfx/src/nsRect.h
gfx/src/nsRegion.h
gfx/src/nsScriptableRegion.h
gfx/src/nsTransform2D.h
gfx/ycbcr/QuellGccWarnings.patch
gfx/ycbcr/TypeFromSize.patch
gfx/ycbcr/convert.patch
gfx/ycbcr/ycbcr_to_rgb565.cpp
gfx/ycbcr/ycbcr_to_rgb565.h
gfx/ycbcr/yuv_convert.cpp
gfx/ycbcr/yuv_convert.h
widget/nsPrintSession.h
widget/nsPrintSettingsImpl.h
--- a/gfx/src/DriverCrashGuard.h
+++ b/gfx/src/DriverCrashGuard.h
@@ -1,16 +1,15 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #ifndef gfx_src_DriverCrashGuard_h__
 #define gfx_src_DriverCrashGuard_h__
 
-#include "gfxCore.h"
 #include "nsCOMPtr.h"
 #include "nsIGfxInfo.h"
 #include "nsIFile.h"
 #include "nsString.h"
 #include <string>
 
 namespace mozilla {
 
--- a/gfx/src/X11Util.h
+++ b/gfx/src/X11Util.h
@@ -17,17 +17,16 @@
 #include "gfxQtPlatform.h"
 #undef CursorShape
 #  include <X11/Xlib.h>
 #else
 #  error Unknown toolkit
 #endif 
 
 #include <string.h>                     // for memset
-#include "gfxCore.h"                    // for NS_GFX
 #include "mozilla/Scoped.h"             // for SCOPED_TEMPLATE
 
 namespace mozilla {
 
 /**
  * Return the default X Display created and used by the UI toolkit.
  */
 inline Display*
@@ -86,17 +85,17 @@ SCOPED_TEMPLATE(ScopedXFree, ScopedXFree
  * Nesting is correctly handled: multiple nested ScopedXErrorHandler's don't interfere with each other's state. However,
  * if SyncAndGetError is not called on the nested ScopedXErrorHandler, then any X errors caused by X calls made while the nested
  * ScopedXErrorHandler was in place may then be caught by the other ScopedXErrorHandler. This is just a result of X being
  * asynchronous and us not doing any implicit syncing: the only method in this class what causes syncing is SyncAndGetError().
  *
  * This class is not thread-safe at all. It is assumed that only one thread is using any ScopedXErrorHandler's. Given that it's
  * not used on Mac, it should be easy to make it thread-safe by using thread-local storage with __thread.
  */
-class NS_GFX ScopedXErrorHandler
+class ScopedXErrorHandler
 {
 public:
     // trivial wrapper around XErrorEvent, just adding ctor initializing by zero.
     struct ErrorEvent
     {
         XErrorEvent mError;
 
         ErrorEvent()
deleted file mode 100644
--- a/gfx/src/gfxCore.h
+++ /dev/null
@@ -1,15 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#ifndef gfxCore_h__
-#define gfxCore_h__
-
-#include "nscore.h"
-
-#define NS_GFX
-#define NS_GFX_(type) type
-#define NS_GFX_STATIC_MEMBER_(type) type
-
-#endif
--- a/gfx/src/gfxCrashReporterUtils.h
+++ b/gfx/src/gfxCrashReporterUtils.h
@@ -1,32 +1,31 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef gfxCrashReporterUtils_h__
 #define gfxCrashReporterUtils_h__
 
-#include "gfxCore.h"
 
 namespace mozilla {
 
 /** \class ScopedGfxFeatureReporter
   *
   * On creation, adds "FeatureName?" to AppNotes
   * On destruction, adds "FeatureName-", or "FeatureName+" if you called SetSuccessful().
   *
   * Any such string is added at most once to AppNotes, and is subsequently skipped.
   *
   * This ScopedGfxFeatureReporter class is designed to be fool-proof to use in functions that
   * have many exit points. We don't want to encourage having function with many exit points.
   * It just happens that our graphics features initialization functions are like that.
   */
-class NS_GFX ScopedGfxFeatureReporter
+class ScopedGfxFeatureReporter
 {
 public:
   explicit ScopedGfxFeatureReporter(const char *aFeature, bool force = false)
     : mFeature(aFeature), mStatusChar('-')
   {
     WriteAppNote(force ? '!' : '?');
   }
   ~ScopedGfxFeatureReporter() {
--- a/gfx/src/moz.build
+++ b/gfx/src/moz.build
@@ -11,17 +11,16 @@ XPIDL_SOURCES += [
 
 XPIDL_MODULE = 'gfx'
 
 DEFINES['MOZ_APP_VERSION'] = '"%s"' % CONFIG['MOZ_APP_VERSION']
 
 EXPORTS += [
     'DriverCrashGuard.h',
     'FilterSupport.h',
-    'gfxCore.h',
     'gfxCrashReporterUtils.h',
     'gfxTelemetry.h',
     'nsBoundingMetrics.h',
     'nsColor.h',
     'nsColorNameList.h',
     'nsColorNames.h',
     'nsCoord.h',
     'nsDeviceContext.h',
--- a/gfx/src/nsColor.cpp
+++ b/gfx/src/nsColor.cpp
@@ -70,18 +70,17 @@ static int ComponentValue(const char16_t
     }
     else {  // not a hex digit, treat it like 0
       component = (component * 16);
     }
   }
   return component;
 }
 
-NS_GFX_(bool) NS_HexToRGB(const nsAString& aColorSpec,
-                                       nscolor* aResult)
+bool NS_HexToRGB(const nsAString& aColorSpec, nscolor* aResult)
 {
   const char16_t* buffer = aColorSpec.BeginReading();
 
   int nameLen = aColorSpec.Length();
   if ((nameLen == 3) || (nameLen == 6)) {
     // Make sure the digits are legal
     for (int i = 0; i < nameLen; i++) {
       char16_t ch = buffer[i];
@@ -116,17 +115,17 @@ NS_GFX_(bool) NS_HexToRGB(const nsAStrin
   }
 
   // Improperly formatted color value
   return false;
 }
 
 // This implements part of the algorithm for legacy behavior described in
 // http://www.whatwg.org/specs/web-apps/current-work/complete/common-microsyntaxes.html#rules-for-parsing-a-legacy-color-value
-NS_GFX_(bool) NS_LooseHexToRGB(const nsString& aColorSpec, nscolor* aResult)
+bool NS_LooseHexToRGB(const nsString& aColorSpec, nscolor* aResult)
 {
   if (aColorSpec.EqualsLiteral("transparent")) {
     return false;
   }
 
   int nameLen = aColorSpec.Length();
   const char16_t* colorSpec = aColorSpec.get();
   if (nameLen > 128) {
@@ -180,17 +179,17 @@ NS_GFX_(bool) NS_LooseHexToRGB(const nsS
   NS_ASSERTION((r >= 0) && (r <= 255), "bad r");
   NS_ASSERTION((g >= 0) && (g <= 255), "bad g");
   NS_ASSERTION((b >= 0) && (b <= 255), "bad b");
 
   *aResult = NS_RGB(r, g, b);
   return true;
 }
 
-NS_GFX_(bool) NS_ColorNameToRGB(const nsAString& aColorName, nscolor* aResult)
+bool NS_ColorNameToRGB(const nsAString& aColorName, nscolor* aResult)
 {
   if (!gColorTable) return false;
 
   int32_t id = gColorTable->Lookup(aColorName);
   if (eColorName_UNKNOWN < id) {
     NS_ASSERTION(uint32_t(id) < eColorName_COUNT,
                  "gColorTable->Lookup messed up");
     if (aResult) {
@@ -198,29 +197,29 @@ NS_GFX_(bool) NS_ColorNameToRGB(const ns
     }
     return true;
   }
   return false;
 }
 
 // Returns kColorNames, an array of all possible color names, and sets
 // *aSizeArray to the size of that array. Do NOT call free() on this array.
-NS_GFX_(const char * const *) NS_AllColorNames(size_t *aSizeArray)
+const char * const * NS_AllColorNames(size_t *aSizeArray)
 {
   *aSizeArray = ArrayLength(kColorNames);
   return kColorNames;
 }
 
 // Macro to blend two colors
 //
 // equivalent to target = (bg*(255-fgalpha) + fg*fgalpha)/255
 #define MOZ_BLEND(target, bg, fg, fgalpha)       \
   FAST_DIVIDE_BY_255(target, (bg)*(255-fgalpha) + (fg)*(fgalpha))
 
-NS_GFX_(nscolor)
+nscolor
 NS_ComposeColors(nscolor aBG, nscolor aFG)
 {
   // This function uses colors that are non premultiplied alpha.
   int r, g, b, a;
 
   int bgAlpha = NS_GET_A(aBG);
   int fgAlpha = NS_GET_A(aFG);
 
@@ -259,34 +258,34 @@ HSL_HueToRGB(float m1, float m2, float h
   if (h < (float)(1.0/2.0))
     return m2;
   if (h < (float)(2.0/3.0))
     return m1 + (m2 - m1)*((float)(2.0/3.0) - h)*6.0f;
   return m1;      
 }
 
 // The float parameters are all expected to be in the range 0-1
-NS_GFX_(nscolor)
+nscolor
 NS_HSL2RGB(float h, float s, float l)
 {
   uint8_t r, g, b;
   float m1, m2;
   if (l <= 0.5f) {
     m2 = l*(s+1);
   } else {
     m2 = l + s - l*s;
   }
   m1 = l*2 - m2;
   r = uint8_t(255 * HSL_HueToRGB(m1, m2, h + 1.0f/3.0f));
   g = uint8_t(255 * HSL_HueToRGB(m1, m2, h));
   b = uint8_t(255 * HSL_HueToRGB(m1, m2, h - 1.0f/3.0f));
   return NS_RGB(r, g, b);  
 }
 
-NS_GFX_(const char*)
+const char*
 NS_RGBToColorName(nscolor aColor)
 {
   for (size_t idx = 0; idx < ArrayLength(kColors); ++idx) {
     if (kColors[idx] == aColor) {
       return kColorNames[idx];
     }
   }
 
--- a/gfx/src/nsColor.h
+++ b/gfx/src/nsColor.h
@@ -3,17 +3,16 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef nsColor_h___
 #define nsColor_h___
 
 #include <stddef.h>                     // for size_t
 #include <stdint.h>                     // for uint8_t, uint32_t
-#include "gfxCore.h"                    // for NS_GFX_
 #include "nscore.h"                     // for nsAString
 
 class nsAString;
 class nsString;
 
 // A color is a 32 bit unsigned integer with four components: R, G, B
 // and A.
 typedef uint32_t nscolor;
@@ -48,42 +47,42 @@ typedef uint32_t nscolor;
   PR_BEGIN_MACRO                                   \
     unsigned tmp_ = v;                             \
     target = ((tmp_ << 8) + tmp_ + 255) >> 16;     \
   PR_END_MACRO
 
 // Translate a hex string to a color. Return true if it parses ok,
 // otherwise return false.
 // This accepts only 3 or 6 digits
-NS_GFX_(bool) NS_HexToRGB(const nsAString& aBuf, nscolor* aResult);
+bool NS_HexToRGB(const nsAString& aBuf, nscolor* aResult);
 
 // Compose one NS_RGB color onto another. The result is what
 // you get if you draw aFG on top of aBG with operator OVER.
-NS_GFX_(nscolor) NS_ComposeColors(nscolor aBG, nscolor aFG);
+nscolor NS_ComposeColors(nscolor aBG, nscolor aFG);
 
 // Translate a hex string to a color. Return true if it parses ok,
 // otherwise return false.
 // This version accepts 1 to 9 digits (missing digits are 0)
-NS_GFX_(bool) NS_LooseHexToRGB(const nsString& aBuf, nscolor* aResult);
+bool NS_LooseHexToRGB(const nsString& aBuf, nscolor* aResult);
 
 // There is no function to translate a color to a hex string, because
 // the hex-string syntax does not support transparency.
 
 // Translate a color name to a color. Return true if it parses ok,
 // otherwise return false.
-NS_GFX_(bool) NS_ColorNameToRGB(const nsAString& aBuf, nscolor* aResult);
+bool NS_ColorNameToRGB(const nsAString& aBuf, nscolor* aResult);
 
 // Returns an array of all possible color names, and sets
 // *aSizeArray to the size of that array. Do NOT call |free()| on this array.
-NS_GFX_(const char * const *) NS_AllColorNames(size_t *aSizeArray);
+const char * const * NS_AllColorNames(size_t *aSizeArray);
 
 // function to convert from HSL color space to RGB color space
 // the float parameters are all expected to be in the range 0-1
-NS_GFX_(nscolor) NS_HSL2RGB(float h, float s, float l);
+nscolor NS_HSL2RGB(float h, float s, float l);
 
 // Return a color name for the given nscolor.  If there is no color
 // name for it, returns null.  If there are multiple possible color
 // names for the given color, the first one in nsColorNameList.h
 // (which is generally the first one in alphabetical order) will be
 // returned.
-NS_GFX_(const char*) NS_RGBToColorName(nscolor aColor);
+const char* NS_RGBToColorName(nscolor aColor);
 
 #endif /* nsColor_h___ */
--- a/gfx/src/nsColorNames.h
+++ b/gfx/src/nsColorNames.h
@@ -1,17 +1,16 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef nsColorNames_h___
 #define nsColorNames_h___
 
-#include "gfxCore.h"
 
-class NS_GFX nsColorNames {
+class nsColorNames {
 public:
   static void AddRefTable(void);
   static void ReleaseTable(void);
 };
 
 #endif /* nsColorNames_h___ */
--- a/gfx/src/nsFont.h
+++ b/gfx/src/nsFont.h
@@ -3,17 +3,16 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef nsFont_h___
 #define nsFont_h___
 
 #include <stdint.h>                     // for uint8_t, uint16_t
 #include <sys/types.h>                  // for int16_t
-#include "gfxCore.h"                    // for NS_GFX
 #include "gfxFontFamilyList.h"
 #include "gfxFontFeatures.h"
 #include "nsAutoPtr.h"                  // for nsRefPtr
 #include "nsCoord.h"                    // for nscoord
 #include "nsStringFwd.h"                // for nsSubstring
 #include "nsString.h"               // for nsString
 #include "nsTArray.h"                   // for nsTArray
 
@@ -35,17 +34,17 @@ const uint8_t kGenericFont_moz_fixed    
 // CSS
 const uint8_t kGenericFont_serif        = 0x02;
 const uint8_t kGenericFont_sans_serif   = 0x04;
 const uint8_t kGenericFont_monospace    = 0x08;
 const uint8_t kGenericFont_cursive      = 0x10;
 const uint8_t kGenericFont_fantasy      = 0x20;
 
 // Font structure.
-struct NS_GFX nsFont {
+struct nsFont {
 
   // list of font families, either named or generic
   mozilla::FontFamilyList fontlist;
 
   // The style of font (normal, italic, oblique; see gfxFontConstants.h)
   uint8_t style;
 
   // Force this font to not be considered a 'generic' font, even if
--- a/gfx/src/nsMargin.h
+++ b/gfx/src/nsMargin.h
@@ -3,17 +3,16 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef NSMARGIN_H
 #define NSMARGIN_H
 
 #include "nsCoord.h"
 #include "nsPoint.h"
-#include "gfxCore.h"
 #include "mozilla/gfx/BaseMargin.h"
 
 struct nsMargin : public mozilla::gfx::BaseMargin<nscoord, nsMargin> {
   typedef mozilla::gfx::BaseMargin<nscoord, nsMargin> Super;
 
   // Constructors
   nsMargin() : Super() {}
   nsMargin(const nsMargin& aMargin) : Super(aMargin) {}
--- a/gfx/src/nsRect.h
+++ b/gfx/src/nsRect.h
@@ -5,31 +5,30 @@
 
 
 #ifndef NSRECT_H
 #define NSRECT_H
 
 #include <stdio.h>                      // for FILE
 #include <stdint.h>                     // for int32_t, int64_t
 #include <algorithm>                    // for min/max
-#include "gfxCore.h"                    // for NS_GFX
 #include "mozilla/Likely.h"             // for MOZ_UNLIKELY
 #include "mozilla/gfx/Rect.h"
 #include "nsCoord.h"                    // for nscoord, etc
 #include "nsISupportsImpl.h"            // for MOZ_COUNT_CTOR, etc
 #include "nsPoint.h"                    // for nsIntPoint, nsPoint
 #include "nsSize.h"                     // for IntSize, nsSize
 #include "nscore.h"                     // for NS_BUILD_REFCNT_LOGGING
 
 struct nsMargin;
 struct nsIntMargin;
 
 typedef mozilla::gfx::IntRect nsIntRect;
 
-struct NS_GFX nsRect :
+struct nsRect :
   public mozilla::gfx::BaseRect<nscoord, nsRect, nsPoint, nsSize, nsMargin> {
   typedef mozilla::gfx::BaseRect<nscoord, nsRect, nsPoint, nsSize, nsMargin> Super;
 
   static void VERIFY_COORD(nscoord aValue) { ::VERIFY_COORD(aValue); }
 
   // Constructors
   nsRect() : Super()
   {
@@ -285,12 +284,12 @@ nsRect::ToInsidePixels(nscoord aAppUnits
 const mozilla::gfx::IntRect& GetMaxSizedIntRect();
 
 // app units are integer multiples of pixels, so no rounding needed
 nsRect
 ToAppUnits(const mozilla::gfx::IntRect& aRect, nscoord aAppUnitsPerPixel);
 
 #ifdef DEBUG
 // Diagnostics
-extern NS_GFX FILE* operator<<(FILE* out, const nsRect& rect);
+extern FILE* operator<<(FILE* out, const nsRect& rect);
 #endif // DEBUG
 
 #endif /* NSRECT_H */
--- a/gfx/src/nsRegion.h
+++ b/gfx/src/nsRegion.h
@@ -4,17 +4,16 @@
 
 
 #ifndef nsRegion_h__
 #define nsRegion_h__
 
 #include <stddef.h>                     // for size_t
 #include <stdint.h>                     // for uint32_t, uint64_t
 #include <sys/types.h>                  // for int32_t
-#include "gfxCore.h"                    // for NS_GFX
 #include "mozilla/ToString.h"           // for mozilla::ToString
 #include "nsCoord.h"                    // for nscoord
 #include "nsError.h"                    // for nsresult
 #include "nsPoint.h"                    // for nsIntPoint, nsPoint
 #include "nsRect.h"                     // for mozilla::gfx::IntRect, nsRect
 #include "nsMargin.h"                   // for nsIntMargin
 #include "nsStringGlue.h"               // for nsCString
 #include "xpcom-config.h"               // for CPP_THROW_NEW
@@ -415,17 +414,17 @@ private:
   pixman_region32_t* Impl() const
   {
     return const_cast<pixman_region32_t*>(&mImpl);
   }
 
 };
 
 
-class NS_GFX nsRegionRectIterator
+class nsRegionRectIterator
 {
   const nsRegion*  mRegion;
   int i;
   int n;
   nsRect rect;
   pixman_box32_t *boxes;
 
 public:
@@ -469,17 +468,17 @@ public:
 
 namespace mozilla {
 namespace gfx {
 
 /**
  * BaseIntRegions use int32_t coordinates.
  */
 template <typename Derived, typename Rect, typename Point, typename Margin>
-class NS_GFX BaseIntRegion
+class BaseIntRegion
 {
   friend class ::nsRegion;
 
 public:
   typedef Rect RectType;
   typedef Point PointType;
   typedef Margin MarginType;
 
@@ -758,17 +757,17 @@ public:
   typedef void (*visitFn)(void *closure, VisitSide side, int x1, int y1, int x2, int y2);
   void VisitEdges (visitFn visit, void *closure)
   {
     mImpl.VisitEdges (visit, closure);
   }
 
   nsCString ToString() const { return mImpl.ToString(); }
 
-  class NS_GFX RectIterator
+  class RectIterator
   {
     nsRegionRectIterator mImpl;
     Rect mTmp;
 
   public:
     explicit RectIterator (const BaseIntRegion& aRegion) : mImpl (aRegion.mImpl) {}
 
     const Rect* Next ()
@@ -820,17 +819,17 @@ private:
   {
     return *static_cast<const Derived*>(this);
   }
 };
 
 } // namespace gfx
 } // namespace mozilla
 
-class NS_GFX nsIntRegion : public mozilla::gfx::BaseIntRegion<nsIntRegion, mozilla::gfx::IntRect, nsIntPoint, nsIntMargin>
+class nsIntRegion : public mozilla::gfx::BaseIntRegion<nsIntRegion, mozilla::gfx::IntRect, nsIntPoint, nsIntMargin>
 {
 public:
   // Forward constructors.
   nsIntRegion() {}
   MOZ_IMPLICIT nsIntRegion(const mozilla::gfx::IntRect& aRect) : BaseIntRegion(aRect) {}
   nsIntRegion(const nsIntRegion& aRegion) : BaseIntRegion(aRegion) {}
   nsIntRegion(nsIntRegion&& aRegion) : BaseIntRegion(mozilla::Move(aRegion)) {}
 
--- a/gfx/src/nsScriptableRegion.h
+++ b/gfx/src/nsScriptableRegion.h
@@ -3,22 +3,21 @@
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef nsScriptableRegion_h
 #define nsScriptableRegion_h
 
 #include "nsIScriptableRegion.h"
-#include "gfxCore.h"
 #include "nsISupports.h"
 #include "nsRegion.h"
 #include "mozilla/Attributes.h"
 
-class NS_GFX nsScriptableRegion final : public nsIScriptableRegion {
+class nsScriptableRegion final : public nsIScriptableRegion {
 public:
 	nsScriptableRegion();
 
 	NS_DECL_ISUPPORTS
 
 	NS_DECL_NSISCRIPTABLEREGION
 
 private:
--- a/gfx/src/nsTransform2D.h
+++ b/gfx/src/nsTransform2D.h
@@ -1,20 +1,19 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef nsTransform2D_h___
 #define nsTransform2D_h___
 
-#include "gfxCore.h"
 #include "nsCoord.h"
 
-class NS_GFX nsTransform2D
+class nsTransform2D
 {
 private:
  /**
   * This represents the following matrix (note that the order of row/column
   * indices is opposite to usual notation)
   *
   *      / m00   0   m20  \
   * M =  |  0   m11  m21  |
--- a/gfx/ycbcr/QuellGccWarnings.patch
+++ b/gfx/ycbcr/QuellGccWarnings.patch
@@ -1,12 +1,12 @@
 diff --git a/gfx/ycbcr/yuv_convert.cpp b/gfx/ycbcr/yuv_convert.cpp
 --- a/gfx/ycbcr/yuv_convert.cpp
 +++ b/gfx/ycbcr/yuv_convert.cpp
-@@ -337,16 +337,17 @@ NS_GFX_(void) ScaleYCbCrToRGB32(const ui
+@@ -337,16 +337,17 @@ void ScaleYCbCrToRGB32(const uint* yplan
                                           source_dx_uv >> kFractionBits);
          }
        }
        else {
          ScaleYUVToRGB32Row_C(y_ptr, u_ptr, v_ptr,
                               dest_pixel, width, source_dx);
        }
  #else
--- a/gfx/ycbcr/TypeFromSize.patch
+++ b/gfx/ycbcr/TypeFromSize.patch
@@ -5,54 +5,54 @@ diff --git a/gfx/ycbcr/yuv_convert.cpp b
  
  namespace gfx {
   
  // 16.16 fixed point arithmetic
  const int kFractionBits = 16;
  const int kFractionMax = 1 << kFractionBits;
  const int kFractionMask = ((1 << kFractionBits) - 1);
  
-+NS_GFX_(YUVType) TypeFromSize(int ywidth, 
-+                              int yheight, 
-+                              int cbcrwidth, 
-+                              int cbcrheight)
++YUVType TypeFromSize(int ywidth, 
++                     int yheight, 
++                     int cbcrwidth, 
++                     int cbcrheight)
 +{
 +  if (ywidth == cbcrwidth && yheight == cbcrheight) {
 +    return YV24;
 +  }
 +  else if (ywidth / 2 == cbcrwidth && yheight == cbcrheight) {
 +    return YV16;
 +  }
 +  else {
 +    return YV12;
 +  }
 +}
 +
  // Convert a frame of YUV to 32 bit ARGB.
- NS_GFX_(void) ConvertYCbCrToRGB32(const uint8* y_buf,
-                                   const uint8* u_buf,
-                                   const uint8* v_buf,
-                                   uint8* rgb_buf,
-                                   int pic_x,
-                                   int pic_y,
-                                   int pic_width,
+ void ConvertYCbCrToRGB32(const uint8* y_buf,
+                          const uint8* u_buf,
+                          const uint8* v_buf,
+                          uint8* rgb_buf,
+                          int pic_x,
+                          int pic_y,
+                          int pic_width,
 diff --git a/gfx/ycbcr/yuv_convert.h b/gfx/ycbcr/yuv_convert.h
 --- a/gfx/ycbcr/yuv_convert.h
 +++ b/gfx/ycbcr/yuv_convert.h
 @@ -36,16 +36,18 @@ enum Rotate {
  // Filter affects how scaling looks.
  enum ScaleFilter {
    FILTER_NONE = 0,        // No filter (point sampled).
    FILTER_BILINEAR_H = 1,  // Bilinear horizontal filter.
    FILTER_BILINEAR_V = 2,  // Bilinear vertical filter.
    FILTER_BILINEAR = 3     // Bilinear filter.
  };
  
-+NS_GFX_(YUVType) TypeFromSize(int ywidth, int yheight, int cbcrwidth, int cbcrheight);
++YUVType TypeFromSize(int ywidth, int yheight, int cbcrwidth, int cbcrheight);
 +
  // Convert a frame of YUV to 32 bit ARGB.
  // Pass in YV16/YV12 depending on source format
- NS_GFX_(void) ConvertYCbCrToRGB32(const uint8* yplane,
-                                   const uint8* uplane,
-                                   const uint8* vplane,
-                                   uint8* rgbframe,
-                                   int pic_x,
-                                   int pic_y,
+ void ConvertYCbCrToRGB32(const uint8* yplane,
+                          const uint8* uplane,
+                          const uint8* vplane,
+                          uint8* rgbframe,
+                          int pic_x,
+                          int pic_y,
--- a/gfx/ycbcr/convert.patch
+++ b/gfx/ycbcr/convert.patch
@@ -66,28 +66,28 @@ diff --git a/gfx/ycbcr/yuv_convert.cpp b
 -    const uint8* v_ptr = v_buf + (y >> y_shift) * uv_pitch;
 -
 -    FastConvertYUVToRGB32Row(y_ptr,
 -                             u_ptr,
 -                             v_ptr,
 -                             rgb_row,
 -                             width);
 -  }
-+NS_GFX_(void) ConvertYCbCrToRGB32(const uint8* y_buf,
-+                                  const uint8* u_buf,
-+                                  const uint8* v_buf,
-+                                  uint8* rgb_buf,
-+                                  int pic_x,
-+                                  int pic_y,
-+                                  int pic_width,
-+                                  int pic_height,
-+                                  int y_pitch,
-+                                  int uv_pitch,
-+                                  int rgb_pitch,
-+                                  YUVType yuv_type) {
++void ConvertYCbCrToRGB32(const uint8* y_buf,
++                         const uint8* u_buf,
++                         const uint8* v_buf,
++                         uint8* rgb_buf,
++                         int pic_x,
++                         int pic_y,
++                         int pic_width,
++                         int pic_height,
++                         int y_pitch,
++                         int uv_pitch,
++                         int rgb_pitch,
++                         YUVType yuv_type) {
 +  unsigned int y_shift = yuv_type == YV12 ? 1 : 0;
 +  unsigned int x_shift = yuv_type == YV24 ? 0 : 1;
 +  // Test for SSE because the optimized code uses movntq, which is not part of MMX.
 +  bool has_sse = supports_mmx() && supports_sse();
 +  // There is no optimized YV24 SSE routine so we check for this and
 +  // fall back to the C code.
 +  has_sse &= yuv_type != YV24;
 +  bool odd_pic_x = yuv_type != YV24 && pic_x % 2 != 0;
@@ -270,30 +270,30 @@ diff --git a/gfx/ycbcr/yuv_convert.cpp b
 -                     int width,
 -                     int height,
 -                     int y_pitch,
 -                     int uv_pitch,
 -                     int rgb_pitch,
 -                     YUVType yuv_type,
 -                     Rotate view_rotate,
 -                     ScaleFilter filter) {
-+NS_GFX_(void) ScaleYCbCrToRGB32(const uint8* y_buf,
-+                                const uint8* u_buf,
-+                                const uint8* v_buf,
-+                                uint8* rgb_buf,
-+                                int source_width,
-+                                int source_height,
-+                                int width,
-+                                int height,
-+                                int y_pitch,
-+                                int uv_pitch,
-+                                int rgb_pitch,
-+                                YUVType yuv_type,
-+                                Rotate view_rotate,
-+                                ScaleFilter filter) {
++void ScaleYCbCrToRGB32(const uint8* y_buf,
++                       const uint8* u_buf,
++                       const uint8* v_buf,
++                       uint8* rgb_buf,
++                       int source_width,
++                       int source_height,
++                       int width,
++                       int height,
++                       int y_pitch,
++                       int uv_pitch,
++                       int rgb_pitch,
++                       YUVType yuv_type,
++                       Rotate view_rotate,
++                       ScaleFilter filter) {
 +  bool has_mmx = supports_mmx();
 +
    // 4096 allows 3 buffers to fit in 12k.
    // Helps performance on CPU with 16K L1 cache.
    // Large enough for 3830x2160 and 30" displays which are 2560x1600.
    const int kFilterBufferSize = 4096;
    // Disable filtering if the screen is too big (to avoid buffer overflows).
    // This should never happen to regular users: they don't have monitors
@@ -464,28 +464,28 @@ diff --git a/gfx/ycbcr/yuv_convert.h b/g
 -                       const uint8* vplane,
 -                       uint8* rgbframe,
 -                       int width,
 -                       int height,
 -                       int ystride,
 -                       int uvstride,
 -                       int rgbstride,
 -                       YUVType yuv_type);
-+NS_GFX_(void) ConvertYCbCrToRGB32(const uint8* yplane,
-+                                  const uint8* uplane,
-+                                  const uint8* vplane,
-+                                  uint8* rgbframe,
-+                                  int pic_x,
-+                                  int pic_y,
-+                                  int pic_width,
-+                                  int pic_height,
-+                                  int ystride,
-+                                  int uvstride,
-+                                  int rgbstride,
-+                                  YUVType yuv_type);
++void ConvertYCbCrToRGB32(const uint8* yplane,
++                         const uint8* uplane,
++                         const uint8* vplane,
++                         uint8* rgbframe,
++                         int pic_x,
++                         int pic_y,
++                         int pic_width,
++                         int pic_height,
++                         int ystride,
++                         int uvstride,
++                         int rgbstride,
++                         YUVType yuv_type);
  
  // Scale a frame of YUV to 32 bit ARGB.
  // Supports rotation and mirroring.
 -void ScaleYUVToRGB32(const uint8* yplane,
 -                     const uint8* uplane,
 -                     const uint8* vplane,
 -                     uint8* rgbframe,
 -                     int source_width,
@@ -496,30 +496,30 @@ diff --git a/gfx/ycbcr/yuv_convert.h b/g
 -                     int uvstride,
 -                     int rgbstride,
 -                     YUVType yuv_type,
 -                     Rotate view_rotate,
 -                     ScaleFilter filter);
 -
 -}  // namespace media
 -
-+NS_GFX_(void) ScaleYCbCrToRGB32(const uint8* yplane,
-+                                const uint8* uplane,
-+                                const uint8* vplane,
-+                                uint8* rgbframe,
-+                                int source_width,
-+                                int source_height,
-+                                int width,
-+                                int height,
-+                                int ystride,
-+                                int uvstride,
-+                                int rgbstride,
-+                                YUVType yuv_type,
-+                                Rotate view_rotate,
-+                                ScaleFilter filter);
++void ScaleYCbCrToRGB32(const uint8* yplane,
++                       const uint8* uplane,
++                       const uint8* vplane,
++                       uint8* rgbframe,
++                       int source_width,
++                       int source_height,
++                       int width,
++                       int height,
++                       int ystride,
++                       int uvstride,
++                       int rgbstride,
++                       YUVType yuv_type,
++                       Rotate view_rotate,
++                       ScaleFilter filter);
 +
 +}  // namespace gfx
 +}  // namespace mozilla
 + 
  #endif  // MEDIA_BASE_YUV_CONVERT_H_
 diff --git a/gfx/ycbcr/yuv_convert_mmx.cpp b/gfx/ycbcr/yuv_convert_mmx.cpp
 new file mode 100644
 --- /dev/null
--- a/gfx/ycbcr/ycbcr_to_rgb565.cpp
+++ b/gfx/ycbcr/ycbcr_to_rgb565.cpp
@@ -276,17 +276,17 @@ static void ScaleYCbCr444ToRGB565_Neares
     y = ctx->y_row[source_x];
     u = ctx->u_row[source_x];
     v = ctx->v_row[source_x];
     ctx->rgb_row[x] = yu2rgb565(y, u, v, dither);
     dither ^= 3;
   }
 }
 
-NS_GFX_(void) ScaleYCbCrToRGB565(const uint8_t *y_buf,
+void ScaleYCbCrToRGB565(const uint8_t *y_buf,
                                  const uint8_t *u_buf,
                                  const uint8_t *v_buf,
                                  uint8_t *rgb_buf,
                                  int source_x0,
                                  int source_y0,
                                  int source_width,
                                  int source_height,
                                  int width,
@@ -532,17 +532,17 @@ NS_GFX_(void) ScaleYCbCrToRGB565(const u
       ctx.y_yweight = yweight;
       ctx.uv_yweight = uvweight;
       (*scale_row)(&ctx, dither);
       dither ^= 2;
     }
   }
 }
 
-NS_GFX_(bool) IsScaleYCbCrToRGB565Fast(int source_x0,
+bool IsScaleYCbCrToRGB565Fast(int source_x0,
                                        int source_y0,
                                        int source_width,
                                        int source_height,
                                        int width,
                                        int height,
                                        YUVType yuv_type,
                                        ScaleFilter filter)
 {
@@ -594,17 +594,17 @@ void yuv_to_rgb565_row_c(uint16 *dst,
   {
     dst[x] = yu2rgb565(y[pic_x+x],
                        u[(pic_x+x)>>x_shift],
                        v[(pic_x+x)>>x_shift],
                        2); // Disable dithering for now.
   }
 }
 
-NS_GFX_(void) ConvertYCbCrToRGB565(const uint8* y_buf,
+void ConvertYCbCrToRGB565(const uint8* y_buf,
                                    const uint8* u_buf,
                                    const uint8* v_buf,
                                    uint8* rgb_buf,
                                    int pic_x,
                                    int pic_y,
                                    int pic_width,
                                    int pic_height,
                                    int y_pitch,
@@ -647,17 +647,17 @@ NS_GFX_(void) ConvertYCbCrToRGB565(const
                           v_buf + uvoffs,
                           x_shift,
                           pic_x,
                           pic_width);
     }
   }
 }
 
-NS_GFX_(bool) IsConvertYCbCrToRGB565Fast(int pic_x,
+bool IsConvertYCbCrToRGB565Fast(int pic_x,
                                          int pic_y,
                                          int pic_width,
                                          int pic_height,
                                          YUVType yuv_type)
 {
 #  if defined(MOZILLA_MAY_SUPPORT_NEON)
   return (yuv_type != YV24 && supports_neon());
 #  else
--- a/gfx/ycbcr/ycbcr_to_rgb565.h
+++ b/gfx/ycbcr/ycbcr_to_rgb565.h
@@ -12,55 +12,55 @@
 #endif
 
 namespace mozilla {
 
 namespace gfx {
 
 #ifdef HAVE_YCBCR_TO_RGB565
 // Convert a frame of YUV to 16 bit RGB565.
-NS_GFX_(void) ConvertYCbCrToRGB565(const uint8* yplane,
+void ConvertYCbCrToRGB565(const uint8* yplane,
                                    const uint8* uplane,
                                    const uint8* vplane,
                                    uint8* rgbframe,
                                    int pic_x,
                                    int pic_y,
                                    int pic_width,
                                    int pic_height,
                                    int ystride,
                                    int uvstride,
                                    int rgbstride,
                                    YUVType yuv_type);
 
 // Used to test if we have an accelerated version.
-NS_GFX_(bool) IsConvertYCbCrToRGB565Fast(int pic_x,
+bool IsConvertYCbCrToRGB565Fast(int pic_x,
                                          int pic_y,
                                          int pic_width,
                                          int pic_height,
                                          YUVType yuv_type);
 
 // Scale a frame of YUV to 16 bit RGB565.
-NS_GFX_(void) ScaleYCbCrToRGB565(const uint8_t *yplane,
+void ScaleYCbCrToRGB565(const uint8_t *yplane,
                                  const uint8_t *uplane,
                                  const uint8_t *vplane,
                                  uint8_t *rgbframe,
                                  int source_x0,
                                  int source_y0,
                                  int source_width,
                                  int source_height,
                                  int width,
                                  int height,
                                  int ystride,
                                  int uvstride,
                                  int rgbstride,
                                  YUVType yuv_type,
                                  ScaleFilter filter);
 
 // Used to test if we have an accelerated version.
-NS_GFX_(bool) IsScaleYCbCrToRGB565Fast(int source_x0,
+bool IsScaleYCbCrToRGB565Fast(int source_x0,
                                        int source_y0,
                                        int source_width,
                                        int source_height,
                                        int width,
                                        int height,
                                        YUVType yuv_type,
                                        ScaleFilter filter);
 #endif // HAVE_YCBCR_TO_RGB565
--- a/gfx/ycbcr/yuv_convert.cpp
+++ b/gfx/ycbcr/yuv_convert.cpp
@@ -26,45 +26,45 @@ namespace mozilla {
 
 namespace gfx {
  
 // 16.16 fixed point arithmetic
 const int kFractionBits = 16;
 const int kFractionMax = 1 << kFractionBits;
 const int kFractionMask = ((1 << kFractionBits) - 1);
 
-NS_GFX_(YUVType) TypeFromSize(int ywidth, 
+YUVType TypeFromSize(int ywidth, 
                               int yheight, 
                               int cbcrwidth, 
                               int cbcrheight)
 {
   if (ywidth == cbcrwidth && yheight == cbcrheight) {
     return YV24;
   }
   else if (ywidth / 2 == cbcrwidth && yheight == cbcrheight) {
     return YV16;
   }
   else {
     return YV12;
   }
 }
 
 // Convert a frame of YUV to 32 bit ARGB.
-NS_GFX_(void) ConvertYCbCrToRGB32(const uint8* y_buf,
-                                  const uint8* u_buf,
-                                  const uint8* v_buf,
-                                  uint8* rgb_buf,
-                                  int pic_x,
-                                  int pic_y,
-                                  int pic_width,
-                                  int pic_height,
-                                  int y_pitch,
-                                  int uv_pitch,
-                                  int rgb_pitch,
-                                  YUVType yuv_type) {
+void ConvertYCbCrToRGB32(const uint8* y_buf,
+                         const uint8* u_buf,
+                         const uint8* v_buf,
+                         uint8* rgb_buf,
+                         int pic_x,
+                         int pic_y,
+                         int pic_width,
+                         int pic_height,
+                         int y_pitch,
+                         int uv_pitch,
+                         int rgb_pitch,
+                         YUVType yuv_type) {
   unsigned int y_shift = yuv_type == YV12 ? 1 : 0;
   unsigned int x_shift = yuv_type == YV24 ? 0 : 1;
   // Test for SSE because the optimized code uses movntq, which is not part of MMX.
   bool has_sse = supports_mmx() && supports_sse();
   // There is no optimized YV24 SSE routine so we check for this and
   // fall back to the C code.
   has_sse &= yuv_type != YV24;
   bool odd_pic_x = yuv_type != YV24 && pic_x % 2 != 0;
@@ -158,30 +158,30 @@ static inline void FilterRows(uint8* ybu
   }
 #endif
 
   FilterRows_C(ybuf, y0_ptr, y1_ptr, source_width, source_y_fraction);
 }
 
 
 // Scale a frame of YUV to 32 bit ARGB.
-NS_GFX_(void) ScaleYCbCrToRGB32(const uint8* y_buf,
-                                const uint8* u_buf,
-                                const uint8* v_buf,
-                                uint8* rgb_buf,
-                                int source_width,
-                                int source_height,
-                                int width,
-                                int height,
-                                int y_pitch,
-                                int uv_pitch,
-                                int rgb_pitch,
-                                YUVType yuv_type,
-                                Rotate view_rotate,
-                                ScaleFilter filter) {
+void ScaleYCbCrToRGB32(const uint8* y_buf,
+                       const uint8* u_buf,
+                       const uint8* v_buf,
+                       uint8* rgb_buf,
+                       int source_width,
+                       int source_height,
+                       int width,
+                       int height,
+                       int y_pitch,
+                       int uv_pitch,
+                       int rgb_pitch,
+                       YUVType yuv_type,
+                       Rotate view_rotate,
+                       ScaleFilter filter) {
   bool has_mmx = supports_mmx();
 
   // 4096 allows 3 buffers to fit in 12k.
   // Helps performance on CPU with 16K L1 cache.
   // Large enough for 3830x2160 and 30" displays which are 2560x1600.
   const int kFilterBufferSize = 4096;
   // Disable filtering if the screen is too big (to avoid buffer overflows).
   // This should never happen to regular users: they don't have monitors
--- a/gfx/ycbcr/yuv_convert.h
+++ b/gfx/ycbcr/yuv_convert.h
@@ -1,17 +1,16 @@
 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef MEDIA_BASE_YUV_CONVERT_H_
 #define MEDIA_BASE_YUV_CONVERT_H_
 
 #include "chromium_types.h"
-#include "gfxCore.h"
 
 namespace mozilla {
 
 namespace gfx {
  
 // Type of YUV surface.
 // The value of these enums matter as they are used to shift vertical indices.
 enum YUVType {
@@ -36,46 +35,46 @@ enum Rotate {
 // Filter affects how scaling looks.
 enum ScaleFilter {
   FILTER_NONE = 0,        // No filter (point sampled).
   FILTER_BILINEAR_H = 1,  // Bilinear horizontal filter.
   FILTER_BILINEAR_V = 2,  // Bilinear vertical filter.
   FILTER_BILINEAR = 3     // Bilinear filter.
 };
 
-NS_GFX_(YUVType) TypeFromSize(int ywidth, int yheight, int cbcrwidth, int cbcrheight);
+YUVType TypeFromSize(int ywidth, int yheight, int cbcrwidth, int cbcrheight);
 
 // Convert a frame of YUV to 32 bit ARGB.
 // Pass in YV16/YV12 depending on source format
-NS_GFX_(void) ConvertYCbCrToRGB32(const uint8* yplane,
-                                  const uint8* uplane,
-                                  const uint8* vplane,
-                                  uint8* rgbframe,
-                                  int pic_x,
-                                  int pic_y,
-                                  int pic_width,
-                                  int pic_height,
-                                  int ystride,
-                                  int uvstride,
-                                  int rgbstride,
-                                  YUVType yuv_type);
+void ConvertYCbCrToRGB32(const uint8* yplane,
+                         const uint8* uplane,
+                         const uint8* vplane,
+                         uint8* rgbframe,
+                         int pic_x,
+                         int pic_y,
+                         int pic_width,
+                         int pic_height,
+                         int ystride,
+                         int uvstride,
+                         int rgbstride,
+                         YUVType yuv_type);
 
 // Scale a frame of YUV to 32 bit ARGB.
 // Supports rotation and mirroring.
-NS_GFX_(void) ScaleYCbCrToRGB32(const uint8* yplane,
-                                const uint8* uplane,
-                                const uint8* vplane,
-                                uint8* rgbframe,
-                                int source_width,
-                                int source_height,
-                                int width,
-                                int height,
-                                int ystride,
-                                int uvstride,
-                                int rgbstride,
-                                YUVType yuv_type,
-                                Rotate view_rotate,
-                                ScaleFilter filter);
+void ScaleYCbCrToRGB32(const uint8* yplane,
+                       const uint8* uplane,
+                       const uint8* vplane,
+                       uint8* rgbframe,
+                       int source_width,
+                       int source_height,
+                       int width,
+                       int height,
+                       int ystride,
+                       int uvstride,
+                       int rgbstride,
+                       YUVType yuv_type,
+                       Rotate view_rotate,
+                       ScaleFilter filter);
 
 } // namespace gfx
 } // namespace mozilla
  
 #endif  // MEDIA_BASE_YUV_CONVERT_H_
--- a/widget/nsPrintSession.h
+++ b/widget/nsPrintSession.h
@@ -3,17 +3,16 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef nsPrintSession_h__
 #define nsPrintSession_h__
 
 #include "nsIPrintSession.h" 
 #include "nsWeakReference.h"
-#include "gfxCore.h"
 
 //*****************************************************************************
 //***    nsPrintSession
 //*****************************************************************************
 
 class nsPrintSession : public nsIPrintSession,
                        public nsSupportsWeakReference
 {
--- a/widget/nsPrintSettingsImpl.h
+++ b/widget/nsPrintSettingsImpl.h
@@ -2,17 +2,16 @@
  *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef nsPrintSettingsImpl_h__
 #define nsPrintSettingsImpl_h__
 
-#include "gfxCore.h"
 #include "nsIPrintSettings.h"  
 #include "nsMargin.h"  
 #include "nsString.h"
 #include "nsWeakReference.h"  
 
 #define NUM_HEAD_FOOT 3
 
 //*****************************************************************************