--- a/image/build/nsImageModule.cpp
+++ b/image/build/nsImageModule.cpp
@@ -57,21 +57,21 @@
 
 #include "nsICOEncoder.h"
 #include "nsPNGEncoder.h"
 #include "nsJPEGEncoder.h"
 #include "nsBMPEncoder.h"
 
 // objects that just require generic constructors
 namespace mozilla {
-namespace imagelib {
+namespace image {
 NS_GENERIC_FACTORY_CONSTRUCTOR(RasterImage)
 }
 }
-using namespace mozilla::imagelib;
+using namespace mozilla::image;
 
 NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(imgLoader, Init)
 NS_GENERIC_FACTORY_CONSTRUCTOR(imgRequestProxy)
 NS_GENERIC_FACTORY_CONSTRUCTOR(imgTools)
 NS_GENERIC_FACTORY_CONSTRUCTOR(nsICOEncoder)
 NS_GENERIC_FACTORY_CONSTRUCTOR(nsJPEGEncoder)
 NS_GENERIC_FACTORY_CONSTRUCTOR(nsPNGEncoder)
 NS_GENERIC_FACTORY_CONSTRUCTOR(nsBMPEncoder)
@@ -131,17 +131,17 @@ imglib_Initialize()
   imgLoader::InitCache();
   return NS_OK;
 }
 
 static void
 imglib_Shutdown()
 {
   imgLoader::Shutdown();
-  mozilla::imagelib::DiscardTracker::Shutdown();
+  mozilla::image::DiscardTracker::Shutdown();
 }
 
 static const mozilla::Module kImageModule = {
   mozilla::Module::kVersion,
   kImageCIDs,
   kImageContracts,
   kImageCategories,
   NULL,

--- a/image/decoders/nsBMPDecoder.cpp
+++ b/image/decoders/nsBMPDecoder.cpp
@@ -48,17 +48,17 @@
 #include "nsBMPDecoder.h"
 
 #include "nsIInputStream.h"
 #include "RasterImage.h"
 #include "imgIContainerObserver.h"
 #include "ImageLogging.h"
 
 namespace mozilla {
-namespace imagelib {
+namespace image {
 
 #ifdef PR_LOGGING
 PRLogModuleInfo *gBMPLog = PR_NewLogModule("BMPDecoder");
 #endif
 
 // Convert from row (1..height) to absolute line (0..height-1)
 #define LINE(row) ((mBIH.height < 0) ? (-mBIH.height - (row)) : ((row) - 1))
 #define PIXEL_OFFSET(row, col) (LINE(row) * mBIH.width + col)
@@ -770,10 +770,10 @@ void nsBMPDecoder::ProcessInfoHeader()
     mBIH.compression = LITTLE_TO_NATIVE32(mBIH.compression);
     mBIH.image_size = LITTLE_TO_NATIVE32(mBIH.image_size);
     mBIH.xppm = LITTLE_TO_NATIVE32(mBIH.xppm);
     mBIH.yppm = LITTLE_TO_NATIVE32(mBIH.yppm);
     mBIH.colors = LITTLE_TO_NATIVE32(mBIH.colors);
     mBIH.important_colors = LITTLE_TO_NATIVE32(mBIH.important_colors);
 }
 
-} // namespace imagelib
+} // namespace image
 } // namespace mozilla

--- a/image/decoders/nsBMPDecoder.h
+++ b/image/decoders/nsBMPDecoder.h
@@ -43,17 +43,17 @@
 
 #include "nsAutoPtr.h"
 #include "imgIDecoderObserver.h"
 #include "gfxColor.h"
 #include "Decoder.h"
 #include "BMPFileHeaders.h"
 
 namespace mozilla {
-namespace imagelib {
+namespace image {
 
 class RasterImage;
 
 /**
  * Decoder for BMP-Files, as used by Windows and OS/2
  */
 class nsBMPDecoder : public Decoder
 {
@@ -158,14 +158,14 @@ inline void Set4BitPixel(PRUint32*& aDec
     SetPixel(aDecoded, idx, aColors);
     if (--aCount > 0) {
         idx = aData & 0xF;
         SetPixel(aDecoded, idx, aColors);
         --aCount;
     }
 }
 
-} // namespace imagelib
+} // namespace image
 } // namespace mozilla
 
 
 #endif
 

--- a/image/decoders/nsGIFDecoder2.cpp
+++ b/image/decoders/nsGIFDecoder2.cpp
@@ -80,17 +80,17 @@ mailing address.
 #include "imgIContainerObserver.h"
 #include "RasterImage.h"
 
 #include "gfxColor.h"
 #include "gfxPlatform.h"
 #include "qcms.h"
 
 namespace mozilla {
-namespace imagelib {
+namespace image {
 
 /*
  * GETN(n, s) requests at least 'n' bytes available from 'q', at start of state 's'
  *
  * Note, the hold will never need to be bigger than 256 bytes to gather up in the hold,
  * as each GIF block (except colormaps) can never be bigger than 256 bytes.
  * Colormaps are directly copied in the resp. global_colormap or the local_colormap of the PAL image frame
  * So a fixed buffer in gif_struct is good enough.
@@ -1099,10 +1099,10 @@ done:
 
 Telemetry::ID
 nsGIFDecoder2::SpeedHistogram()
 {
   return Telemetry::IMAGE_DECODE_SPEED_GIF;
 }
 
 
-} // namespace imagelib
+} // namespace image
 } // namespace mozilla

--- a/image/decoders/nsGIFDecoder2.h
+++ b/image/decoders/nsGIFDecoder2.h
@@ -43,17 +43,17 @@
 
 #include "nsCOMPtr.h"
 #include "Decoder.h"
 #include "imgIDecoderObserver.h"
 
 #include "GIF2.h"
 
 namespace mozilla {
-namespace imagelib {
+namespace image {
 class RasterImage;
 
 //////////////////////////////////////////////////////////////////////
 // nsGIFDecoder2 Definition
 
 class nsGIFDecoder2 : public Decoder
 {
 public:
@@ -97,12 +97,12 @@ private:
   PRUint8 mLastFlushedPass;
   PRUint8 mColorMask;        // Apply this to the pixel to keep within colormap
   bool mGIFOpen;
   bool mSawTransparency;
 
   gif_struct mGIFStruct;
 };
 
-} // namespace imagelib
+} // namespace image
 } // namespace mozilla
 
 #endif

--- a/image/decoders/nsICODecoder.cpp
+++ b/image/decoders/nsICODecoder.cpp
@@ -51,17 +51,17 @@
 #include "nsIComponentManager.h"
 #include "RasterImage.h"
 #include "imgIContainerObserver.h"
 
 #include "nsIProperties.h"
 #include "nsISupportsPrimitives.h"
 
 namespace mozilla {
-namespace imagelib {
+namespace image {
 
 #define ICONCOUNTOFFSET 4
 #define DIRENTRYOFFSET 6
 #define BITMAPINFOSIZE 40
 #define PREFICONSIZE 16
 
 // ----------------------------------------
 // Actual Data Processing
@@ -606,10 +606,10 @@ nsICODecoder::ProcessDirEntry(IconDirEnt
   aTarget.mBitCount = LITTLE_TO_NATIVE16(aTarget.mBitCount);
   memcpy(&aTarget.mBytesInRes, mDirEntryArray + 8, sizeof(aTarget.mBytesInRes));
   aTarget.mBytesInRes = LITTLE_TO_NATIVE32(aTarget.mBytesInRes);
   memcpy(&aTarget.mImageOffset, mDirEntryArray + 12, 
          sizeof(aTarget.mImageOffset));
   aTarget.mImageOffset = LITTLE_TO_NATIVE32(aTarget.mImageOffset);
 }
 
-} // namespace imagelib
+} // namespace image
 } // namespace mozilla

--- a/image/decoders/nsICODecoder.h
+++ b/image/decoders/nsICODecoder.h
@@ -45,17 +45,17 @@
 #include "nsAutoPtr.h"
 #include "Decoder.h"
 #include "imgIDecoderObserver.h"
 #include "nsBMPDecoder.h"
 #include "nsPNGDecoder.h"
 #include "ICOFileHeaders.h"
 
 namespace mozilla {
-namespace imagelib {
+namespace image {
 
 class RasterImage;
 
 class nsICODecoder : public Decoder
 {
 public:
 
   nsICODecoder(RasterImage &aImage, imgIDecoderObserver* aObserver);
@@ -118,12 +118,12 @@ private:
   // Holds the potential bytes for a bitmap information header
   char mBIHraw[40];
   // Stores whether or not the icon file we are processing has type 1 (icon)
   bool mIsCursor;
   // Stores whether or not the contained resource is a PNG
   bool mIsPNG;
 };
 
-} // namespace imagelib
+} // namespace image
 } // namespace mozilla
 
 #endif

--- a/image/decoders/nsIconDecoder.cpp
+++ b/image/decoders/nsIconDecoder.cpp
@@ -43,17 +43,17 @@
 #include "RasterImage.h"
 #include "imgIContainerObserver.h"
 #include "nspr.h"
 #include "nsRect.h"
 
 #include "ImageErrors.h"
 
 namespace mozilla {
-namespace imagelib {
+namespace image {
 
 nsIconDecoder::nsIconDecoder(RasterImage &aImage, imgIDecoderObserver* aObserver)
  : Decoder(aImage, aObserver),
    mWidth(-1),
    mHeight(-1),
    mPixBytesRead(0),
    mPixBytesTotal(0),
    mImageData(nsnull),
@@ -160,10 +160,10 @@ nsIconDecoder::WriteInternal(const char 
         // Consume all excess data silently
         aCount = 0;
 
         break;
     }
   }
 }
 
-} // namespace imagelib
+} // namespace image
 } // namespace mozilla

--- a/image/decoders/nsIconDecoder.h
+++ b/image/decoders/nsIconDecoder.h
@@ -43,17 +43,17 @@
 
 #include "Decoder.h"
 
 #include "nsCOMPtr.h"
 
 #include "imgIDecoderObserver.h"
 
 namespace mozilla {
-namespace imagelib {
+namespace image {
 class RasterImage;
 
 //////////////////////////////////////////////////////////////////////////////////////////////
 // The icon decoder is a decoder specifically tailored for loading icons 
 // from the OS. We've defined our own little format to represent these icons
 // and this decoder takes that format and converts it into 24-bit RGB with alpha channel
 // support. It was modeled a bit off the PPM decoder.
 //
@@ -89,12 +89,12 @@ public:
 
 enum {
   iconStateStart      = 0,
   iconStateHaveHeight = 1,
   iconStateReadPixels = 2,
   iconStateFinished   = 3
 };
 
-} // namespace imagelib
+} // namespace image
 } // namespace mozilla
 
 #endif // nsIconDecoder_h__

--- a/image/decoders/nsJPEGDecoder.cpp
+++ b/image/decoders/nsJPEGDecoder.cpp
@@ -69,17 +69,17 @@ METHODDEF(void)
 ycc_rgb_convert_argb (j_decompress_ptr cinfo,
                  JSAMPIMAGE input_buf, JDIMENSION input_row,
                  JSAMPARRAY output_buf, int num_rows);
 }
 
 static void cmyk_convert_rgb(JSAMPROW row, JDIMENSION width);
 
 namespace mozilla {
-namespace imagelib {
+namespace image {
 
 #if defined(PR_LOGGING)
 PRLogModuleInfo *gJPEGlog = PR_NewLogModule("JPEGDecoder");
 static PRLogModuleInfo *gJPEGDecoderAccountingLog = PR_NewLogModule("JPEGDecoderAccounting");
 #else
 #define gJPEGlog
 #define gJPEGDecoderAccountingLog
 #endif
@@ -885,17 +885,17 @@ term_source (j_decompress_ptr jd)
   // recover from.
   NS_ABORT_IF_FALSE(decoder->mState != JPEG_ERROR,
                     "Calling term_source on a JPEG with mState == JPEG_ERROR!");
 
   // Notify using a helper method to get around protectedness issues.
   decoder->NotifyDone();
 }
 
-} // namespace imagelib
+} // namespace image
 } // namespace mozilla
 
 
 /**************** YCbCr -> Cairo's RGB24/ARGB32 conversion: most common case **************/
 
 /*
  * YCbCr is defined per CCIR 601-1, except that Cb and Cr are
  * normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5.

--- a/image/decoders/nsJPEGDecoder.h
+++ b/image/decoders/nsJPEGDecoder.h
@@ -58,17 +58,17 @@
 
 extern "C" {
 #include "jpeglib.h"
 }
 
 #include <setjmp.h>
 
 namespace mozilla {
-namespace imagelib {
+namespace image {
 
 typedef struct {
     struct jpeg_error_mgr pub;  /* "public" fields for IJG library*/
     jmp_buf setjmp_buffer;      /* For handling catastropic errors */
 } decoder_error_mgr;
 
 typedef enum {
     JPEG_HEADER,                          /* Reading JFIF headers */
@@ -123,12 +123,12 @@ public:
   qcms_profile *mInProfile;
   qcms_transform *mTransform;
 
   bool mReading;
 
   PRUint32 mCMSMode;
 };
 
-} // namespace imagelib
+} // namespace image
 } // namespace mozilla
 
 #endif // nsJPEGDecoder_h__

--- a/image/decoders/nsPNGDecoder.cpp
+++ b/image/decoders/nsPNGDecoder.cpp
@@ -56,17 +56,17 @@
 #include "nsColor.h"
 
 #include "nspr.h"
 #include "png.h"
 
 #include "gfxPlatform.h"
 
 namespace mozilla {
-namespace imagelib {
+namespace image {
 
 #ifdef PR_LOGGING
 static PRLogModuleInfo *gPNGLog = PR_NewLogModule("PNGDecoder");
 static PRLogModuleInfo *gPNGDecoderAccountingLog =
                         PR_NewLogModule("PNGDecoderAccounting");
 #endif
 
 /* limit image dimensions (bug #251381) */
@@ -882,10 +882,10 @@ nsPNGDecoder::warning_callback(png_struc
 
 Telemetry::ID
 nsPNGDecoder::SpeedHistogram()
 {
   return Telemetry::IMAGE_DECODE_SPEED_PNG;
 }
 
 
-} // namespace imagelib
+} // namespace image
 } // namespace mozilla

--- a/image/decoders/nsPNGDecoder.h
+++ b/image/decoders/nsPNGDecoder.h
@@ -48,17 +48,17 @@
 
 #include "nsCOMPtr.h"
 
 #include "png.h"
 
 #include "qcms.h"
 
 namespace mozilla {
-namespace imagelib {
+namespace image {
 class RasterImage;
 
 class nsPNGDecoder : public Decoder
 {
 public:
   nsPNGDecoder(RasterImage &aImage, imgIDecoderObserver* aObserver);
   virtual ~nsPNGDecoder();
 
@@ -136,12 +136,12 @@ public:
   static void PNGAPI warning_callback(png_structp png_ptr,
                                       png_const_charp warning_msg);
 
   // This is defined in the PNG spec as an invariant. We use it to
   // do manual validation without libpng.
   static const PRUint8 pngSignatureBytes[];
 };
 
-} // namespace imagelib
+} // namespace image
 } // namespace mozilla
 
 #endif // nsPNGDecoder_h__

--- a/image/encoders/bmp/nsBMPEncoder.cpp
+++ b/image/encoders/bmp/nsBMPEncoder.cpp
@@ -540,17 +540,17 @@ nsBMPEncoder::InitInfoHeader(PRUint32 aB
   mBMPInfoHeader.xppm = 0;
   mBMPInfoHeader.yppm = 0;
 }
 
 // Encodes the BMP file header mBMPFileHeader
 void 
 nsBMPEncoder::EncodeFileHeader() 
 {  
-  mozilla::imagelib::BMPFILEHEADER littleEndianBFH = mBMPFileHeader;
+  mozilla::image::BMPFILEHEADER littleEndianBFH = mBMPFileHeader;
   littleEndianBFH.filesize = NATIVE32_TO_LITTLE(littleEndianBFH.filesize);
   littleEndianBFH.reserved = NATIVE32_TO_LITTLE(littleEndianBFH.reserved);
   littleEndianBFH.dataoffset= NATIVE32_TO_LITTLE(littleEndianBFH.dataoffset);
   littleEndianBFH.bihsize = NATIVE32_TO_LITTLE(littleEndianBFH.bihsize);
 
   memcpy(mImageBufferCurr, &littleEndianBFH.signature, 
          sizeof(littleEndianBFH.signature));
   mImageBufferCurr += sizeof(littleEndianBFH.signature);
@@ -567,17 +567,17 @@ nsBMPEncoder::EncodeFileHeader()
          sizeof(littleEndianBFH.bihsize));
   mImageBufferCurr += sizeof(littleEndianBFH.bihsize);
 }
 
 // Encodes the BMP infor header mBMPInfoHeader
 void 
 nsBMPEncoder::EncodeInfoHeader()
 {
-  mozilla::imagelib::BMPINFOHEADER littleEndianmBIH = mBMPInfoHeader;
+  mozilla::image::BMPINFOHEADER littleEndianmBIH = mBMPInfoHeader;
   littleEndianmBIH.width =  NATIVE32_TO_LITTLE(littleEndianmBIH.width);
   littleEndianmBIH.height = NATIVE32_TO_LITTLE(littleEndianmBIH.height); 
   littleEndianmBIH.planes = NATIVE16_TO_LITTLE(littleEndianmBIH.planes);
   littleEndianmBIH.bpp = NATIVE16_TO_LITTLE(littleEndianmBIH.bpp);
   littleEndianmBIH.compression = NATIVE32_TO_LITTLE(
                                  littleEndianmBIH.compression);
   littleEndianmBIH.image_size = NATIVE32_TO_LITTLE(
                                 littleEndianmBIH.image_size);

--- a/image/encoders/bmp/nsBMPEncoder.h
+++ b/image/encoders/bmp/nsBMPEncoder.h
@@ -93,18 +93,18 @@ protected:
   // Obtains the current offset filled up to for the image buffer
   inline PRInt32 GetCurrentImageBufferOffset()
   {
     return static_cast<PRInt32>(mImageBufferCurr - mImageBufferStart);
   }
 
   // These headers will always contain endian independent stuff 
   // They store the BMP headers which will be encoded
-  mozilla::imagelib::BMPFILEHEADER mBMPFileHeader;
-  mozilla::imagelib::BMPINFOHEADER mBMPInfoHeader;
+  mozilla::image::BMPFILEHEADER mBMPFileHeader;
+  mozilla::image::BMPINFOHEADER mBMPInfoHeader;
 
   // Keeps track of the start of the image buffer
   PRUint8* mImageBufferStart;
   // Keeps track of the current position in the image buffer
   PRUint8* mImageBufferCurr;
   // Keeps track of the image buffer size
   PRUint32 mImageBufferSize;
   // Keeps track of the number of bytes in the image buffer which are read

--- a/image/encoders/ico/nsICOEncoder.cpp
+++ b/image/encoders/ico/nsICOEncoder.cpp
@@ -41,17 +41,17 @@
 #include "nsPNGEncoder.h"
 #include "nsICOEncoder.h"
 #include "prmem.h"
 #include "prprf.h"
 #include "nsString.h"
 #include "nsStreamUtils.h"
 
 using namespace mozilla;
-using namespace mozilla::imagelib;
+using namespace mozilla::image;
 
 NS_IMPL_THREADSAFE_ISUPPORTS3(nsICOEncoder, imgIEncoder, nsIInputStream, nsIAsyncInputStream)
 
 nsICOEncoder::nsICOEncoder() : mImageBufferStart(nsnull),
                                mImageBufferCurr(0),
                                mImageBufferSize(0), 
                                mImageBufferReadPoint(0), 
                                mFinished(false),

--- a/image/encoders/ico/nsICOEncoder.h
+++ b/image/encoders/ico/nsICOEncoder.h
@@ -103,18 +103,18 @@ protected:
 
   // Holds either a PNG or a BMP depending on the encoding options specified
   // or if no encoding options specified will use the default (PNG)
   nsCOMPtr<imgIEncoder> mContainedEncoder;
 
   // These headers will always contain endian independent stuff.
   // Don't trust the width and height of mICODirEntry directly,
   // instead use the accessors GetRealWidth() and GetRealHeight().
-  mozilla::imagelib::IconFileHeader mICOFileHeader;
-  mozilla::imagelib::IconDirEntry mICODirEntry;
+  mozilla::image::IconFileHeader mICOFileHeader;
+  mozilla::image::IconDirEntry mICODirEntry;
 
   // Keeps track of the start of the image buffer
   PRUint8* mImageBufferStart;
   // Keeps track of the current position in the image buffer
   PRUint8* mImageBufferCurr;
   // Keeps track of the image buffer size
   PRUint32 mImageBufferSize;
   // Keeps track of the number of bytes in the image buffer which are read

--- a/image/src/BMPFileHeaders.h
+++ b/image/src/BMPFileHeaders.h
@@ -34,17 +34,17 @@
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef MOZILLA_IMAGELIB_BMPHEADERS_H_
 #define MOZILLA_IMAGELIB_BMPHEADERS_H_
 
 namespace mozilla {
-  namespace imagelib {
+  namespace image {
 
     struct BMPFILEHEADER {
       char signature[2]; // String "BM"
       PRUint32 filesize;
       PRInt32 reserved; // Zero
       PRUint32 dataoffset; // Offset to raster data
 
       PRUint32 bihsize;
@@ -92,17 +92,17 @@ namespace mozilla {
       PRUint8 redLeftShift;
       PRUint8 redRightShift;
       PRUint8 greenLeftShift;
       PRUint8 greenRightShift;
       PRUint8 blueLeftShift;
       PRUint8 blueRightShift;
     };
 
-  } // namespace imagelib
+  } // namespace image
 } // namespace mozilla
 
 #define BITFIELD_LENGTH 12 // Length of the bitfields structure in the bmp file
 #define USE_RGB
 
 // BMPINFOHEADER.compression defines
 #ifndef BI_RGB
 #define BI_RGB 0

--- a/image/src/Decoder.cpp
+++ b/image/src/Decoder.cpp
@@ -37,17 +37,17 @@
  * ***** END LICENSE BLOCK ***** */
 
 #include "Decoder.h"
 #include "nsIServiceManager.h"
 #include "nsIConsoleService.h"
 #include "nsIScriptError.h"
 
 namespace mozilla {
-namespace imagelib {
+namespace image {
 
 Decoder::Decoder(RasterImage &aImage, imgIDecoderObserver* aObserver)
   : mImage(aImage)
   , mObserver(aObserver)
   , mDecodeFlags(0)
   , mDecodeDone(false)
   , mDataError(false)
   , mFrameCount(0)
@@ -321,10 +321,10 @@ Decoder::PostDecoderError(nsresult aFail
 
   mFailCode = aFailureCode;
 
   // XXXbholley - we should report the image URI here, but imgContainer
   // needs to know its URI first
   NS_WARNING("Image decoding error - This is probably a bug!");
 }
 
-} // namespace imagelib
+} // namespace image
 } // namespace mozilla

--- a/image/src/Decoder.h
+++ b/image/src/Decoder.h
@@ -39,17 +39,17 @@
 #ifndef MOZILLA_IMAGELIB_DECODER_H_
 #define MOZILLA_IMAGELIB_DECODER_H_
 
 #include "RasterImage.h"
 
 #include "imgIDecoderObserver.h"
 
 namespace mozilla {
-namespace imagelib {
+namespace image {
 
 class Decoder
 {
 public:
 
   Decoder(RasterImage& aImage, imgIDecoderObserver* aObserver);
   virtual ~Decoder();
 
@@ -216,12 +216,12 @@ private:
   nsresult mFailCode;
 
   bool mInitialized;
   bool mSizeDecode;
   bool mInFrame;
   bool mIsAnimated;
 };
 
-} // namespace imagelib
+} // namespace image
 } // namespace mozilla
 
 #endif // MOZILLA_IMAGELIB_DECODER_H_

--- a/image/src/DiscardTracker.cpp
+++ b/image/src/DiscardTracker.cpp
@@ -37,17 +37,17 @@
 
 #include "nsComponentManagerUtils.h"
 #include "nsITimer.h"
 #include "RasterImage.h"
 #include "DiscardTracker.h"
 #include "mozilla/Preferences.h"
 
 namespace mozilla {
-namespace imagelib {
+namespace image {
 
 static bool sInitialized = false;
 static bool sTimerOn = false;
 static PRUint32 sMinDiscardTimeoutMs = 10000; /* Default if pref unreadable. */
 static nsITimer *sTimer = nsnull;
 static struct DiscardTrackerNode sHead, sSentinel, sTail;
 
 /*
@@ -284,10 +284,10 @@ DiscardTracker::TimerCallback(nsITimer *
   Reset(&sSentinel);
 
   // If there's nothing in front of the sentinel, the next callback
   // is guaranteed to be a no-op. Disable the timer as an optimization.
   if (sSentinel.prev == &sHead)
     TimerOff();
 }
 
-} // namespace imagelib
+} // namespace image
 } // namespace mozilla

--- a/image/src/DiscardTracker.h
+++ b/image/src/DiscardTracker.h
@@ -38,17 +38,17 @@
 #ifndef mozilla_imagelib_DiscardTracker_h_
 #define mozilla_imagelib_DiscardTracker_h_
 
 #define DISCARD_TIMEOUT_PREF "image.mem.min_discard_timeout_ms"
 
 class nsITimer;
 
 namespace mozilla {
-namespace imagelib {
+namespace image {
 class RasterImage;
 
 // Struct to make a RasterImage insertable into the tracker list. This
 // is embedded within each RasterImage object, and we do 'this->curr = this'
 // on RasterImage construction. Thus, a RasterImage must always call
 // DiscardTracker::Remove() in its destructor to avoid having the tracker
 // point to bogus memory.
 struct DiscardTrackerNode
@@ -79,12 +79,12 @@ class DiscardTracker
     static void DiscardAll();
   private:
     static nsresult Initialize();
     static nsresult TimerOn();
     static void TimerOff();
     static void TimerCallback(nsITimer *aTimer, void *aClosure);
 };
 
-} // namespace imagelib
+} // namespace image
 } // namespace mozilla
 
 #endif /* mozilla_imagelib_DiscardTracker_h_ */

--- a/image/src/ICOFileHeaders.h
+++ b/image/src/ICOFileHeaders.h
@@ -35,17 +35,17 @@
  *
  * ***** END LICENSE BLOCK ***** */
 
 
 #ifndef MOZILLA_IMAGELIB_ICOHEADERS_H_
 #define MOZILLA_IMAGELIB_ICOHEADERS_H_
 
 namespace mozilla {
-  namespace imagelib {
+  namespace image {
 
     #define ICONFILEHEADERSIZE 6
     #define ICODIRENTRYSIZE 16
     #define PNGSIGNATURESIZE 8
     #define BMPFILEHEADERSIZE 14
 
     struct IconFileHeader
     {
@@ -68,12 +68,12 @@ namespace mozilla {
         PRUint16 mBitCount; // ICO
         PRUint16 mYHotspot; // CUR
       };
       PRUint32  mBytesInRes;
       PRUint32  mImageOffset;
     };
 
 
-  } // namespace imagelib
+  } // namespace image
 } // namespace mozilla
 
 #endif

--- a/image/src/Image.cpp
+++ b/image/src/Image.cpp
@@ -33,17 +33,17 @@
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "Image.h"
 
 namespace mozilla {
-namespace imagelib {
+namespace image {
 
 // Constructor
 Image::Image(imgStatusTracker* aStatusTracker) :
   mInnerWindowId(0),
   mAnimationConsumers(0),
   mAnimationMode(kNormalAnimMode),
   mInitialized(false),
   mAnimating(false),
@@ -169,10 +169,10 @@ Image::EvaluateAnimation()
     nsresult rv = StartAnimation();
     mAnimating = NS_SUCCEEDED(rv);
   } else if (mAnimating && !ShouldAnimate()) {
     StopAnimation();
     mAnimating = false;
   }
 }
 
-} // namespace imagelib
+} // namespace image
 } // namespace mozilla

--- a/image/src/Image.h
+++ b/image/src/Image.h
@@ -38,17 +38,17 @@
 #ifndef MOZILLA_IMAGELIB_IMAGE_H_
 #define MOZILLA_IMAGELIB_IMAGE_H_
 
 #include "imgIContainer.h"
 #include "imgStatusTracker.h"
 #include "prtypes.h"
 
 namespace mozilla {
-namespace imagelib {
+namespace image {
 
 class Image : public imgIContainer
 {
 public:
   // From NS_DECL_IMGICONTAINER:
   NS_SCRIPTABLE NS_IMETHOD GetAnimationMode(PRUint16 *aAnimationMode);
   NS_SCRIPTABLE NS_IMETHOD SetAnimationMode(PRUint16 aAnimationMode);
 
@@ -158,12 +158,12 @@ protected:
    * Extended by child classes, if they have additional
    * conditions for being able to animate
    */
   virtual bool ShouldAnimate() {
     return mAnimationConsumers > 0 && mAnimationMode != kDontAnimMode;
   }
 };
 
-} // namespace imagelib
+} // namespace image
 } // namespace mozilla
 
 #endif // MOZILLA_IMAGELIB_IMAGE_H_

--- a/image/src/RasterImage.cpp
+++ b/image/src/RasterImage.cpp
@@ -68,17 +68,17 @@
 #include "gfxContext.h"
 
 #include "mozilla/Preferences.h"
 #include "mozilla/StdInt.h"
 #include "mozilla/Telemetry.h"
 #include "mozilla/TimeStamp.h"
 
 using namespace mozilla;
-using namespace mozilla::imagelib;
+using namespace mozilla::image;
 using namespace mozilla::layers;
 
 // a mask for flags that will affect the decoding
 #define DECODE_FLAGS_MASK (imgIContainer::FLAG_DECODE_NO_PREMULTIPLY_ALPHA | imgIContainer::FLAG_DECODE_NO_COLORSPACE_CONVERSION)
 #define DECODE_FLAGS_DEFAULT 0
 
 /* Accounting for compressed data */
 #if defined(PR_LOGGING)
@@ -169,17 +169,17 @@ DiscardingEnabled()
 
     enabled = (PR_GetEnv("MOZ_DISABLE_IMAGE_DISCARD") == nsnull);
   }
 
   return enabled;
 }
 
 namespace mozilla {
-namespace imagelib {
+namespace image {
 
 #ifndef DEBUG
 NS_IMPL_ISUPPORTS3(RasterImage, imgIContainer, nsIProperties,
                    nsISupportsWeakReference)
 #else
 NS_IMPL_ISUPPORTS4(RasterImage, imgIContainer, nsIProperties,
                    imgIContainerDebug, nsISupportsWeakReference)
 #endif
@@ -2949,10 +2949,10 @@ RasterImage::GetFramesNotified(PRUint32 
   NS_ENSURE_ARG_POINTER(aFramesNotified);
 
   *aFramesNotified = mFramesNotified;
 
   return NS_OK;
 }
 #endif
 
-} // namespace imagelib
+} // namespace image
 } // namespace mozilla

--- a/image/src/RasterImage.h
+++ b/image/src/RasterImage.h
@@ -157,17 +157,17 @@ class nsIInputStream;
  * in Init().
  */
 
 namespace mozilla {
 namespace layers {
 class LayerManager;
 class ImageContainer;
 }
-namespace imagelib {
+namespace image {
 
 class imgDecodeWorker;
 class Decoder;
 
 class RasterImage : public Image
                   , public nsIProperties
                   , public nsSupportsWeakReference
 #ifdef DEBUG
@@ -632,12 +632,12 @@ class imgDecodeRequestor : public nsRunn
         con->RequestDecode();
       return NS_OK;
     }
 
   private:
     nsWeakPtr mContainer;
 };
 
-} // namespace imagelib
+} // namespace image
 } // namespace mozilla
 
 #endif /* mozilla_imagelib_RasterImage_h_ */

--- a/image/src/SVGDocumentWrapper.cpp
+++ b/image/src/SVGDocumentWrapper.cpp
@@ -61,17 +61,17 @@
 #include "gfxRect.h"
 #include "nsSVGSVGElement.h"
 #include "nsSVGLength2.h"
 #include "nsSVGEffects.h"
 
 using namespace mozilla::dom;
 
 namespace mozilla {
-namespace imagelib {
+namespace image {
 
 NS_IMPL_ISUPPORTS4(SVGDocumentWrapper,
                    nsIStreamListener,
                    nsIRequestObserver,
                    nsIObserver,
                    nsISupportsWeakReference)
 
 SVGDocumentWrapper::SVGDocumentWrapper()
@@ -459,10 +459,10 @@ SVGDocumentWrapper::GetRootSVGElem()
   Element* rootElem = mViewer->GetDocument()->GetRootElement();
   if (!rootElem || !rootElem->IsSVG(nsGkAtoms::svg)) {
     return nsnull;
   }
 
   return static_cast<nsSVGSVGElement*>(rootElem);
 }
 
-} // namespace imagelib
+} // namespace image
 } // namespace mozilla

--- a/image/src/SVGDocumentWrapper.h
+++ b/image/src/SVGDocumentWrapper.h
@@ -57,17 +57,17 @@ class nsIFrame;
 struct nsIntSize;
 class nsSVGSVGElement;
 
 #define SVG_MIMETYPE     "image/svg+xml"
 #define OBSERVER_SVC_CID "@mozilla.org/observer-service;1"
 
 
 namespace mozilla {
-namespace imagelib {
+namespace image {
 
 class SVGDocumentWrapper MOZ_FINAL : public nsIStreamListener,
                                      public nsIObserver,
                                      nsSupportsWeakReference
 {
 public:
   SVGDocumentWrapper();
   ~SVGDocumentWrapper();
@@ -182,12 +182,12 @@ private:
 
   nsCOMPtr<nsIContentViewer>  mViewer;
   nsCOMPtr<nsILoadGroup>      mLoadGroup;
   nsCOMPtr<nsIStreamListener> mListener;
   bool                        mIgnoreInvalidation;
   bool                        mRegisteredForXPCOMShutdown;
 };
 
-} // namespace imagelib
+} // namespace image
 } // namespace mozilla
 
 #endif // mozilla_imagelib_SVGDocumentWrapper_h_

--- a/image/src/VectorImage.cpp
+++ b/image/src/VectorImage.cpp
@@ -54,17 +54,17 @@
 #include "gfxDrawable.h"
 #include "gfxUtils.h"
 #include "nsSVGSVGElement.h"
 
 namespace mozilla {
 
 using namespace dom;
 
-namespace imagelib {
+namespace image {
 
 // Helper-class: SVGRootRenderingObserver
 class SVGRootRenderingObserver : public nsSVGRenderingObserver {
 public:
   SVGRootRenderingObserver(SVGDocumentWrapper* aDocWrapper,
                            VectorImage*        aVectorImage)
     : nsSVGRenderingObserver(),
       mDocWrapper(aDocWrapper),
@@ -742,10 +742,10 @@ VectorImage::InvalidateObserver()
   }
 
   nsCOMPtr<imgIDecoderObserver> decoderObs(do_QueryReferent(mObserver));
   if (decoderObs) {
     decoderObs->OnStopFrame(nsnull, imgIContainer::FRAME_CURRENT);
   }
 }
 
-} // namespace imagelib
+} // namespace image
 } // namespace mozilla

--- a/image/src/VectorImage.h
+++ b/image/src/VectorImage.h
@@ -46,17 +46,17 @@
 
 class imgIDecoderObserver;
 
 namespace mozilla {
 namespace layers {
 class LayerManager;
 class ImageContainer;
 }
-namespace imagelib {
+namespace image {
 
 class SVGDocumentWrapper;
 class SVGRootRenderingObserver;
 
 class VectorImage : public Image,
                     public nsIStreamListener
 {
 public:
@@ -127,12 +127,12 @@ private:
   bool           mIsFullyLoaded:1;        // Has OnStopRequest been called?
   bool           mIsDrawing:1;            // Are we currently drawing?
   bool           mHaveAnimations:1;       // Is our SVG content SMIL-animated?
                                           // (Only set after mIsFullyLoaded.)
   bool           mHaveRestrictedRegion:1; // Are we a restricted-region clone
                                           // created via ExtractFrame?
 };
 
-} // namespace imagelib
+} // namespace image
 } // namespace mozilla
 
 #endif // mozilla_imagelib_VectorImage_h_

--- a/image/src/imgLoader.cpp
+++ b/image/src/imgLoader.cpp
@@ -91,17 +91,17 @@
 // until this point, we have an evil hack:
 #include "nsIHttpChannelInternal.h"  
 #include "nsIContentSecurityPolicy.h"
 #include "nsIChannelPolicy.h"
 
 #include "nsContentUtils.h"
 
 using namespace mozilla;
-using namespace mozilla::imagelib;
+using namespace mozilla::image;
 
 #if defined(DEBUG_pavlov) || defined(DEBUG_timeless)
 #include "nsISimpleEnumerator.h"
 #include "nsXPCOM.h"
 #include "nsISupportsPrimitives.h"
 #include "nsXPIDLString.h"
 #include "nsComponentManagerUtils.h"
 

--- a/image/src/imgRequest.cpp
+++ b/image/src/imgRequest.cpp
@@ -82,17 +82,17 @@
 #include "mozilla/Preferences.h"
 
 #include "DiscardTracker.h"
 #include "nsAsyncRedirectVerifyHelper.h"
 
 #define SVG_MIMETYPE "image/svg+xml"
 
 using namespace mozilla;
-using namespace mozilla::imagelib;
+using namespace mozilla::image;
 
 static bool gInitializedPrefCaches = false;
 static bool gDecodeOnDraw = false;
 static bool gDiscardable = false;
 
 static void
 InitPrefCaches()
 {

--- a/image/src/imgRequest.h
+++ b/image/src/imgRequest.h
@@ -66,19 +66,19 @@
 class imgCacheValidator;
 
 class imgRequestProxy;
 class imgCacheEntry;
 class imgMemoryReporter;
 class imgRequestNotifyRunnable;
 
 namespace mozilla {
-namespace imagelib {
+namespace image {
 class Image;
-} // namespace imagelib
+} // namespace image
 } // namespace mozilla
 
 class imgRequest : public imgIDecoderObserver,
                    public nsIStreamListener,
                    public nsSupportsWeakReference,
                    public nsIChannelEventSink,
                    public nsIInterfaceRequestor,
                    public nsIAsyncVerifyRedirectCallback
@@ -222,17 +222,17 @@ private:
   // The URI of the resource we ended up loading after all redirects, etc.
   nsCOMPtr<nsIURI> mCurrentURI;
   // The principal of the document which loaded this image. Used when validating for CORS.
   nsCOMPtr<nsIPrincipal> mLoadingPrincipal;
   // The principal of this image.
   nsCOMPtr<nsIPrincipal> mPrincipal;
   // Status-tracker -- transferred to mImage, when it gets instantiated
   nsAutoPtr<imgStatusTracker> mStatusTracker;
-  nsRefPtr<mozilla::imagelib::Image> mImage;
+  nsRefPtr<mozilla::image::Image> mImage;
   nsCOMPtr<nsIProperties> mProperties;
   nsCOMPtr<nsISupports> mSecurityInfo;
   nsCOMPtr<nsIChannel> mChannel;
   nsCOMPtr<nsIInterfaceRequestor> mPrevChannelSink;
 
   nsTObserverArray<imgRequestProxy*> mObservers;
 
   nsCOMPtr<nsITimedChannel> mTimedChannel;

--- a/image/src/imgRequestProxy.cpp
+++ b/image/src/imgRequestProxy.cpp
@@ -50,17 +50,17 @@
 #include "nsCRT.h"
 
 #include "Image.h"
 #include "ImageErrors.h"
 #include "ImageLogging.h"
 
 #include "nspr.h"
 
-using namespace mozilla::imagelib;
+using namespace mozilla::image;
 
 NS_IMPL_ADDREF(imgRequestProxy)
 NS_IMPL_RELEASE(imgRequestProxy)
 
 NS_INTERFACE_MAP_BEGIN(imgRequestProxy)
   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, imgIRequest)
   NS_INTERFACE_MAP_ENTRY(imgIRequest)
   NS_INTERFACE_MAP_ENTRY(nsIRequest)

--- a/image/src/imgRequestProxy.h
+++ b/image/src/imgRequestProxy.h
@@ -62,19 +62,19 @@
      0x11b2,                                         \
     {0x8f, 0x65, 0x9c, 0x46, 0x2e, 0xe2, 0xbc, 0x95} \
 }
 
 class imgRequestNotifyRunnable;
 class imgStatusNotifyRunnable;
 
 namespace mozilla {
-namespace imagelib {
+namespace image {
 class Image;
-} // namespace imagelib
+} // namespace image
 } // namespace mozilla
 
 class imgRequestProxy : public imgIRequest, 
                         public nsISupportsPriority, 
                         public nsISecurityInfoProvider,
                         public nsITimedChannel
 {
 public:
@@ -86,17 +86,17 @@ public:
   // nsITimedChannel declared below
 
   imgRequestProxy();
   virtual ~imgRequestProxy();
 
   // Callers to Init or ChangeOwner are required to call NotifyListener after
   // (although not immediately after) doing so.
   nsresult Init(imgRequest *request, nsILoadGroup *aLoadGroup,
-                mozilla::imagelib::Image* aImage,
+                mozilla::image::Image* aImage,
                 nsIURI* aURI, imgIDecoderObserver *aObserver);
 
   nsresult ChangeOwner(imgRequest *aNewOwner); // this will change mOwner.  Do not call this if the previous
                                                // owner has already sent notifications out!
 
   void AddToLoadGroup();
   void RemoveFromLoadGroup(bool releaseLoadGroup);
 
@@ -125,17 +125,17 @@ public:
   }
   void SetNotificationsDeferred(bool aDeferNotifications)
   {
     mDeferNotifications = aDeferNotifications;
   }
 
   // Setter for our |mImage| pointer, for imgRequest to use, once it
   // instantiates an Image.
-  void SetImage(mozilla::imagelib::Image* aImage);
+  void SetImage(mozilla::image::Image* aImage);
 
   // Removes all animation consumers that were created with
   // IncrementAnimationConsumers. This is necessary since we need
   // to do it before the proxy itself is destroyed. See
   // imgRequest::RemoveProxy
   void ClearAnimationConsumers();
 
 protected:
@@ -223,17 +223,17 @@ private:
   // means that imgRequest::mObservers will not have any stale pointers in it.
   nsRefPtr<imgRequest> mOwner;
 
   // The URI of our request.
   nsCOMPtr<nsIURI> mURI;
 
   // The image we represent. Is null until data has been received, and is then
   // set by imgRequest.
-  nsRefPtr<mozilla::imagelib::Image> mImage;
+  nsRefPtr<mozilla::image::Image> mImage;
 
   // Our principal. Is null until data has been received from the channel, and
   // is then set by imgRequest.
   nsCOMPtr<nsIPrincipal> mPrincipal;
 
   // mListener is only promised to be a weak ref (see imgILoader.idl),
   // but we actually keep a strong ref to it until we've seen our
   // first OnStopRequest.

--- a/image/src/imgStatusTracker.cpp
+++ b/image/src/imgStatusTracker.cpp
@@ -41,17 +41,17 @@
 
 #include "imgRequest.h"
 #include "imgIContainer.h"
 #include "imgRequestProxy.h"
 #include "Image.h"
 #include "ImageLogging.h"
 #include "RasterImage.h"
 
-using namespace mozilla::imagelib;
+using namespace mozilla::image;
 
 static nsresult
 GetResultFromImageStatus(PRUint32 aStatus)
 {
   if (aStatus & imgIRequest::STATUS_ERROR)
     return NS_IMAGELIB_ERROR_FAILURE;
   if (aStatus & imgIRequest::STATUS_LOAD_COMPLETE)
     return NS_IMAGELIB_SUCCESS_LOAD_FINISHED;

--- a/image/src/imgStatusTracker.h
+++ b/image/src/imgStatusTracker.h
@@ -42,19 +42,19 @@
 
 class imgIContainer;
 class imgRequest;
 class imgRequestProxy;
 class imgStatusNotifyRunnable;
 class imgRequestNotifyRunnable;
 struct nsIntRect;
 namespace mozilla {
-namespace imagelib {
+namespace image {
 class Image;
-} // namespace imagelib
+} // namespace image
 } // namespace mozilla
 
 
 #include "nsCOMPtr.h"
 #include "nsIRunnable.h"
 #include "prtypes.h"
 #include "nscore.h"
 
@@ -79,24 +79,24 @@ enum {
  */
 
 class imgStatusTracker
 {
 public:
   // aImage is the image that this status tracker will pass to the
   // imgRequestProxys in SyncNotify() and EmulateRequestFinished(), and must be
   // alive as long as this instance is, because we hold a weak reference to it.
-  imgStatusTracker(mozilla::imagelib::Image* aImage);
+  imgStatusTracker(mozilla::image::Image* aImage);
   imgStatusTracker(const imgStatusTracker& aOther);
 
   // Image-setter, for imgStatusTrackers created by imgRequest::Init, which
   // are created before their Image is created.  This method should only
   // be called once, and only on an imgStatusTracker that was initialized
   // without an image.
-  void SetImage(mozilla::imagelib::Image* aImage);
+  void SetImage(mozilla::image::Image* aImage);
 
   // Schedule an asynchronous "replaying" of all the notifications that would
   // have to happen to put us in the current state.
   // We will also take note of any notifications that happen between the time
   // Notify() is called and when we call SyncNotify on |proxy|, and replay them
   // as well.
   void Notify(imgRequest* request, imgRequestProxy* proxy);
 
@@ -177,15 +177,15 @@ public:
 private:
   friend class imgStatusNotifyRunnable;
   friend class imgRequestNotifyRunnable;
 
   nsCOMPtr<nsIRunnable> mRequestRunnable;
 
   // A weak pointer to the Image, because it owns us, and we
   // can't create a cycle.
-  mozilla::imagelib::Image* mImage;
+  mozilla::image::Image* mImage;
   PRUint32 mState;
   nsresult mImageStatus;
   bool mHadLastPart;
 };
 
 #endif

--- a/image/src/imgTools.cpp
+++ b/image/src/imgTools.cpp
@@ -48,17 +48,17 @@
 #include "nsStringStream.h"
 #include "nsComponentManagerUtils.h"
 #include "nsWeakReference.h"
 #include "nsIInterfaceRequestorUtils.h"
 #include "nsStreamUtils.h"
 #include "nsNetUtil.h"
 #include "RasterImage.h"
 
-using namespace mozilla::imagelib;
+using namespace mozilla::image;
 
 /* ========== imgITools implementation ========== */
 
 
 
 NS_IMPL_ISUPPORTS1(imgTools, imgITools)
 
 imgTools::imgTools()