--- a/intl/chardet/public/Makefile.in
+++ b/intl/chardet/public/Makefile.in
@@ -52,17 +52,15 @@ XPIDLSRCS       = \
 
 EXPORTS		= \
 		nsCharsetDetectionAdaptorCID.h \
 		nsDetectionConfident.h \
 		nsDocumentCharsetInfoCID.h \
 		nsICharsetDetectionAdaptor.h \
 		nsICharsetDetectionObserver.h \
 		nsICharsetDetector.h \
-		nsIMetaCharsetService.h \
 		nsIStringCharsetDetector.h \
-		nsIXMLEncodingService.h \
 		nsMetaCharsetCID.h \
 		nsXMLEncodingCID.h \
 		$(NULL)
 
 include $(topsrcdir)/config/rules.mk
 

deleted file mode 100644
--- a/intl/chardet/public/nsIMetaCharsetService.h
+++ /dev/null
@@ -1,58 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla Public License Version
- * 1.1 (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- * http://www.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either of the GNU General Public License Version 2 or later (the "GPL"),
- * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * 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 ***** */
-
-#ifndef nsIMetaCharsetService_h__
-#define nsIMetaCharsetService_h__
-#include "nsISupports.h"
-
-
-// {218F2AC1-0A48-11d3-B3BA-00805F8A6670}
-#define NS_IMETA_CHARSET_SERVICE_IID \
-{ 0x218f2ac1, 0xa48, 0x11d3, { 0xb3, 0xba, 0x0, 0x80, 0x5f, 0x8a, 0x66, 0x70 } }
-
-class nsIMetaCharsetService : public nsISupports {
-public:
-   NS_DECLARE_STATIC_IID_ACCESSOR(NS_IMETA_CHARSET_SERVICE_IID)
-
-   NS_IMETHOD Start() = 0;
-   NS_IMETHOD End() = 0;
-};
-
-NS_DEFINE_STATIC_IID_ACCESSOR(nsIMetaCharsetService,
-                              NS_IMETA_CHARSET_SERVICE_IID)
-
-#endif // nsIMetaCharsetService_h__

deleted file mode 100644
--- a/intl/chardet/public/nsIXMLEncodingService.h
+++ /dev/null
@@ -1,59 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla Public License Version
- * 1.1 (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- * http://www.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either of the GNU General Public License Version 2 or later (the "GPL"),
- * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * 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 ***** */
-
-#ifndef nsIXMLEncodingService_h__
-#define nsIXMLEncodingService_h__
-#include "nsISupports.h"
-
-
-// {12BB8F11-2389-11d3-B3BF-00805F8A6670}
-#define NS_IXML_ENCODING_SERVICE_IID \
-{ 0x12bb8f11, 0x2389, 0x11d3, { 0xb3, 0xbf, 0x0, 0x80, 0x5f, 0x8a, 0x66, 0x70 } }
-
-
-class nsIXMLEncodingService : public nsISupports {
-public:
-   NS_DECLARE_STATIC_IID_ACCESSOR(NS_IXML_ENCODING_SERVICE_IID)
-
-   NS_IMETHOD Start() = 0;
-   NS_IMETHOD End() = 0;
-};
-
-NS_DEFINE_STATIC_IID_ACCESSOR(nsIXMLEncodingService,
-                              NS_IXML_ENCODING_SERVICE_IID)
-
-#endif // nsIXMLEncodingService_h__

--- a/intl/chardet/src/Makefile.in
+++ b/intl/chardet/src/Makefile.in
@@ -48,19 +48,16 @@ EXPORT_LIBRARY = 1
 IS_COMPONENT = 1
 MODULE_NAME = nsChardetModule
 GRE_MODULE = 1
 LIBXUL_LIBRARY  = 1
 
 
 CPPSRCS		= \
 		nsObserverBase.cpp \
-		nsXMLEncodingObserver.cpp \
-		nsMetaCharsetObserver.cpp \
-		nsDetectionAdaptor.cpp \
 		nsDebugDetector.cpp \
 		nsCyrillicDetector.cpp \
 		nsDocumentCharsetInfo.cpp \
 		nsChardetModule.cpp \
 		$(NULL)
 
 EXTRA_DSO_LDOPTS = \
 	$(MOZ_UNICHARUTIL_LIBS) \

--- a/intl/chardet/src/nsCharDetConstructors.h
+++ b/intl/chardet/src/nsCharDetConstructors.h
@@ -44,32 +44,26 @@
 #ifndef nsCharDetConstructors_h__
 #define nsCharDetConstructors_h__
 
 // chardet
 #include "nsISupports.h"
 #include "nsMetaCharsetCID.h"
 #include "nsICharsetDetector.h"
 #include "nsICharsetAlias.h"
-#include "nsMetaCharsetObserver.h"
 #include "nsDocumentCharsetInfo.h"
-#include "nsXMLEncodingObserver.h"
 #include "nsICharsetDetectionAdaptor.h"
 #include "nsICharsetDetectionObserver.h"
-#include "nsDetectionAdaptor.h"
 #include "nsIStringCharsetDetector.h"
 #include "nsCyrillicDetector.h"
 #include "nsDocumentCharsetInfoCID.h"
 #include "nsXMLEncodingCID.h"
 #include "nsCharsetDetectionAdaptorCID.h"
 
-NS_GENERIC_FACTORY_CONSTRUCTOR(nsMetaCharsetObserver)
 NS_GENERIC_FACTORY_CONSTRUCTOR(nsDocumentCharsetInfo)
-NS_GENERIC_FACTORY_CONSTRUCTOR(nsXMLEncodingObserver)
-NS_GENERIC_FACTORY_CONSTRUCTOR(nsDetectionAdaptor)
 NS_GENERIC_FACTORY_CONSTRUCTOR(nsRUProbDetector)
 NS_GENERIC_FACTORY_CONSTRUCTOR(nsUKProbDetector)
 NS_GENERIC_FACTORY_CONSTRUCTOR(nsRUStringProbDetector)
 NS_GENERIC_FACTORY_CONSTRUCTOR(nsUKStringProbDetector)
 
 #ifdef INCLUDE_DBGDETECTOR
 NS_GENERIC_FACTORY_CONSTRUCTOR(ns1stBlkDbgDetector)
 NS_GENERIC_FACTORY_CONSTRUCTOR(ns2ndBlkDbgDetector)

--- a/intl/chardet/src/nsChardetModule.cpp
+++ b/intl/chardet/src/nsChardetModule.cpp
@@ -37,52 +37,43 @@
 
 #include "mozilla/ModuleUtils.h"
 #include "nsCOMPtr.h"
 #include "nsICategoryManager.h"
 #include "nsIServiceManager.h"
 
 #include "nsCharDetConstructors.h"
 
-NS_DEFINE_NAMED_CID(NS_META_CHARSET_CID);
 NS_DEFINE_NAMED_CID(NS_DOCUMENTCHARSETINFO_CID);
-NS_DEFINE_NAMED_CID(NS_XML_ENCODING_CID);
-NS_DEFINE_NAMED_CID(NS_CHARSET_DETECTION_ADAPTOR_CID);
 NS_DEFINE_NAMED_CID(NS_RU_PROBDETECTOR_CID);
 NS_DEFINE_NAMED_CID(NS_UK_PROBDETECTOR_CID);
 NS_DEFINE_NAMED_CID(NS_RU_STRING_PROBDETECTOR_CID);
 NS_DEFINE_NAMED_CID(NS_UK_STRING_PROBDETECTOR_CID);
 #ifdef INCLUDE_DBGDETECTOR
 NS_DEFINE_NAMED_CID(NS_1STBLKDBG_DETECTOR_CID);
 NS_DEFINE_NAMED_CID(NS_2NDBLKDBG_DETECTOR_CID);
 NS_DEFINE_NAMED_CID(NS_LASTBLKDBG_DETECTOR_CID);
 #endif /* INCLUDE_DBGDETECTOR */
 
 static const mozilla::Module::CIDEntry kChardetCIDs[] = {
-  { &kNS_META_CHARSET_CID, false, NULL, nsMetaCharsetObserverConstructor },
   { &kNS_DOCUMENTCHARSETINFO_CID, false, NULL, nsDocumentCharsetInfoConstructor },
-  { &kNS_XML_ENCODING_CID, false, NULL, nsXMLEncodingObserverConstructor },
-  { &kNS_CHARSET_DETECTION_ADAPTOR_CID, false, NULL, nsDetectionAdaptorConstructor },
   { &kNS_RU_PROBDETECTOR_CID, false, NULL, nsRUProbDetectorConstructor },
   { &kNS_UK_PROBDETECTOR_CID, false, NULL, nsUKProbDetectorConstructor },
   { &kNS_RU_STRING_PROBDETECTOR_CID, false, NULL, nsRUStringProbDetectorConstructor },
   { &kNS_UK_STRING_PROBDETECTOR_CID, false, NULL, nsUKStringProbDetectorConstructor },
 #ifdef INCLUDE_DBGDETECTOR
   { &kNS_1STBLKDBG_DETECTOR_CID, false, NULL, ns1stBlkDbgDetectorConstructor },
   { &kNS_2NDBLKDBG_DETECTOR_CID, false, NULL, ns2ndBlkDbgDetectorConstructor },
   { &kNS_LASTBLKDBG_DETECTOR_CID, false, NULL, nsLastBlkDbgDetectorConstructor },
 #endif /* INCLUDE_DBGDETECTOR */
   { NULL }
 };
 
 static const mozilla::Module::ContractIDEntry kChardetContracts[] = {
-  { NS_META_CHARSET_CONTRACTID, &kNS_META_CHARSET_CID },
   { NS_DOCUMENTCHARSETINFO_CONTRACTID, &kNS_DOCUMENTCHARSETINFO_CID },
-  { NS_XML_ENCODING_CONTRACTID, &kNS_XML_ENCODING_CID },
-  { NS_CHARSET_DETECTION_ADAPTOR_CONTRACTID, &kNS_CHARSET_DETECTION_ADAPTOR_CID },
   { NS_CHARSET_DETECTOR_CONTRACTID_BASE "ruprob", &kNS_RU_PROBDETECTOR_CID },
   { NS_CHARSET_DETECTOR_CONTRACTID_BASE "ukprob", &kNS_UK_PROBDETECTOR_CID },
   { NS_STRCDETECTOR_CONTRACTID_BASE "ruprob", &kNS_RU_STRING_PROBDETECTOR_CID },
   { NS_STRCDETECTOR_CONTRACTID_BASE "ukprob", &kNS_UK_STRING_PROBDETECTOR_CID },
 #ifdef INCLUDE_DBGDETECTOR
   { NS_CHARSET_DETECTOR_CONTRACTID_BASE "1stblkdbg", &kNS_1STBLKDBG_DETECTOR_CID },
   { NS_CHARSET_DETECTOR_CONTRACTID_BASE "2ndblkdbg", &kNS_2NDBLKDBG_DETECTOR_CID },
   { NS_CHARSET_DETECTOR_CONTRACTID_BASE "lastblkdbg", &kNS_LASTBLKDBG_DETECTOR_CID },

deleted file mode 100644
--- a/intl/chardet/src/nsDetectionAdaptor.cpp
+++ /dev/null
@@ -1,171 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla Public License Version
- * 1.1 (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- * http://www.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *   Pierre Phaneuf <pp@ludusdesign.com>
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either of the GNU General Public License Version 2 or later (the "GPL"),
- * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * 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 "nsString.h"
-#include "plstr.h"
-#include "pratom.h"
-#include "nsCharDetDll.h"
-#include "nsIParser.h"
-#include "nsIDocument.h"
-#include "nsDetectionAdaptor.h"
-#include "nsIContentSink.h"
-
-
-//--------------------------------------------------------------
-NS_IMETHODIMP nsMyObserver::Notify(
-    const char* aCharset, nsDetectionConfident aConf)
-{
-    nsresult rv = NS_OK;
-
-    if(mWeakRefParser) {
-      nsCAutoString existingCharset;
-      PRInt32 existingSource;
-      mWeakRefParser->GetDocumentCharset(existingCharset, existingSource);  
-      if (existingSource >= kCharsetFromAutoDetection) 
-        return NS_OK;
-    }
-     
-    if(!mCharset.Equals(aCharset)) {
-      if(mNotifyByReload) {
-        rv = mWebShellSvc->StopDocumentLoad();
-        rv = mWebShellSvc->ReloadDocument(aCharset, kCharsetFromAutoDetection);
-      } else {
-        nsDependentCString newcharset(aCharset);
-        if (mWeakRefParser) {
-          mWeakRefParser->SetDocumentCharset(newcharset, kCharsetFromAutoDetection);
-          nsCOMPtr<nsIContentSink> contentSink = mWeakRefParser->GetContentSink();
-          if (contentSink)
-            contentSink->SetDocumentCharset(newcharset);
-        }
-        if(mWeakRefDocument) 
-          mWeakRefDocument->SetDocumentCharacterSet(newcharset);
-      }
-    }
-    return NS_OK;
-}
-//--------------------------------------------------------------
-NS_IMETHODIMP nsMyObserver::Init( nsIWebShellServices* aWebShellSvc, 
-                   nsIDocument* aDocument,
-                   nsIParser* aParser,
-                   const char* aCharset,
-                   const char* aCommand)
-{
-    if(aCommand) {
-        mCommand = aCommand;
-    }
-    if(aCharset) {
-        mCharset = aCharset;
-    }
-    if(aDocument) {
-        mWeakRefDocument = aDocument;
-    }
-    if(aParser) {
-        mWeakRefParser = aParser;
-    }
-    if(nsnull != aWebShellSvc)
-    {
-        mWebShellSvc = aWebShellSvc;
-        return NS_OK;
-    }
-    return NS_ERROR_ILLEGAL_VALUE;
-}
-//--------------------------------------------------------------
-NS_IMPL_ISUPPORTS1 ( nsMyObserver ,nsICharsetDetectionObserver)
-
-//--------------------------------------------------------------
-nsDetectionAdaptor::nsDetectionAdaptor( void ) 
-{
-     mDontFeedToDetector = PR_TRUE;
-}
-//--------------------------------------------------------------
-nsDetectionAdaptor::~nsDetectionAdaptor()
-{
-}
-
-//--------------------------------------------------------------
-NS_IMPL_ISUPPORTS2 (nsDetectionAdaptor, nsIParserFilter, nsICharsetDetectionAdaptor)
-
-//--------------------------------------------------------------
-NS_IMETHODIMP nsDetectionAdaptor::Init(
-    nsIWebShellServices* aWebShellSvc, nsICharsetDetector *aDetector,
-    nsIDocument* aDocument, nsIParser* aParser, const char* aCharset,
-    const char* aCommand)
-{
-  if((nsnull != aWebShellSvc) && (nsnull != aDetector) && (nsnull != aCharset))
-  {
-    nsresult rv = NS_OK;
-    mObserver = new nsMyObserver();
-    if(!mObserver)
-       return NS_ERROR_OUT_OF_MEMORY;
-
-    rv = mObserver->Init(aWebShellSvc, aDocument, aParser, aCharset, aCommand);
-    if(NS_SUCCEEDED(rv)) {
-      rv = aDetector->Init(mObserver.get());
-      if(NS_SUCCEEDED(rv)) {
-        mDetector = aDetector;
-        mDontFeedToDetector = PR_FALSE;
-        return NS_OK;
-      }
-    }
-  }
-  return NS_ERROR_ILLEGAL_VALUE;
-}
-//--------------------------------------------------------------
-NS_IMETHODIMP nsDetectionAdaptor::RawBuffer
-    (const char * buffer, PRUint32 * buffer_length) 
-{
-    if((mDontFeedToDetector) || (!mDetector))
-       return NS_OK;
-    nsresult rv = NS_OK;
-    rv = mDetector->DoIt((const char*)buffer, *buffer_length, &mDontFeedToDetector);
-    if(mObserver) 
-       mObserver->SetNotifyByReload(PR_TRUE);
-
-    return NS_OK;
-}
-//--------------------------------------------------------------
-NS_IMETHODIMP nsDetectionAdaptor::Finish()
-{
-    if((mDontFeedToDetector) || (!mDetector))
-       return NS_OK;
-    nsresult rv = NS_OK;
-    rv = mDetector->Done();
-
-    return NS_OK;
-}
-

deleted file mode 100644
--- a/intl/chardet/src/nsDetectionAdaptor.h
+++ /dev/null
@@ -1,131 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla Public License Version
- * 1.1 (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- * http://www.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either of the GNU General Public License Version 2 or later (the "GPL"),
- * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * 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 ***** */
-#ifndef nsDetectionAdaptor_h__
-#define nsDetectionAdaptor_h__
-
-#include "nsCOMPtr.h"
-#include "nsIWebShellServices.h"
-
-#include "nsIParserFilter.h"
-static NS_DEFINE_IID(kIParserFilterIID, NS_IPARSERFILTER_IID);
-
-class nsIDocument;
-class CToken;
-
-//--------------------------------------------------------------
-class nsMyObserver : public nsICharsetDetectionObserver
-{
- public:
-   NS_DECL_ISUPPORTS
-
- public:
-   nsMyObserver( void )
-   {
-     mWebShellSvc = nsnull;
-     mNotifyByReload = PR_FALSE;
-     mWeakRefDocument = nsnull;
-     mWeakRefParser = nsnull;
-   }
-   virtual  ~nsMyObserver( void )
-   {
-     // do not release nor delete mWeakRefDocument
-     // do not release nor delete mWeakRefParser
-   }
-
-
-   // Methods to support nsICharsetDetectionAdaptor
-   NS_IMETHOD Init(nsIWebShellServices* aWebShellSvc, 
-                   nsIDocument* aDocument,
-                   nsIParser* aParser,
-                   const char* aCharset,
-                   const char* aCommand);
-
-   // Methods to support nsICharsetDetectionObserver
-   NS_IMETHOD Notify(const char* aCharset, nsDetectionConfident aConf);
-   void SetNotifyByReload(PRBool aByReload) { mNotifyByReload = aByReload; }
- private:
-     nsCOMPtr<nsIWebShellServices> mWebShellSvc;
-     PRBool mNotifyByReload;
-
-     //The adaptor is owned by parser as filter, and adaptor owns detector, 
-     //which in turn owns observer. Parser also live within the lifespan of 
-     //document. The ownership tree is like:
-     //  document->parser->adaptor->detector->observer
-     //We do not want to own Document & Parser to avoid ownership loop. That 
-     //will cause memory leakage. 
-     //If in future this chain got changed, ie. parser outlives document, or 
-     //detector outlives parser, we might want to change weak reference here. 
-     nsIDocument* mWeakRefDocument;
-     nsIParser* mWeakRefParser;
-     nsCAutoString mCharset;
-     nsCAutoString mCommand;
-};
-
-class nsDetectionAdaptor : 
-                           public nsIParserFilter,
-                           public nsICharsetDetectionAdaptor
-{
- public:
-   NS_DECL_ISUPPORTS
-
- public:
-   nsDetectionAdaptor( void );
-   virtual  ~nsDetectionAdaptor( void );
-
-   // Methods to support nsICharsetDetectionAdaptor
-   NS_IMETHOD Init(nsIWebShellServices* aWebShellSvc, nsICharsetDetector *aDetector, 
-                   nsIDocument* aDocument,
-                   nsIParser* aParser,
-                   const char* aCharset,
-                   const char* aCommand=nsnull);
-  
-   // Methode to suppor nsIParserFilter
-   NS_IMETHOD RawBuffer(const char * buffer, PRUint32 * buffer_length) ;
-   NS_IMETHOD Finish();
-
-   // really don't care the following two, only because they are defined
-   // in nsIParserFilter.h
-   NS_IMETHOD WillAddToken(CToken & token) { return NS_OK; }
-   NS_IMETHOD ProcessTokens( void ) {return NS_OK;}
-
-  private:
-     nsCOMPtr<nsICharsetDetector> mDetector;
-     PRBool mDontFeedToDetector;
-     nsCOMPtr<nsMyObserver> mObserver; 
-};
-
-#endif /* nsDetectionAdaptor_h__ */

deleted file mode 100644
--- a/intl/chardet/src/nsMetaCharsetObserver.cpp
+++ /dev/null
@@ -1,440 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla Public License Version
- * 1.1 (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- * http://www.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1999
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either of the GNU General Public License Version 2 or later (the "GPL"),
- * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * 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 "nsDeque.h"
-#include "nsICharsetAlias.h"
-#include "nsMetaCharsetObserver.h"
-#include "nsIMetaCharsetService.h"
-#include "nsIElementObserver.h"
-#include "nsIObserver.h"
-#include "nsIObserverService.h"
-#include "nsISupports.h"
-#include "nsCRT.h"
-#include "nsIParser.h"
-#include "pratom.h"
-#include "nsCharDetDll.h"
-#include "nsIServiceManager.h"
-#include "nsObserverBase.h"
-#include "nsWeakReference.h"
-#include "nsIParserService.h"
-#include "nsParserCIID.h"
-#include "nsMetaCharsetCID.h"
-#include "nsReadableUtils.h"
-#include "nsUnicharUtils.h"
-
-static NS_DEFINE_CID(kCharsetAliasCID, NS_CHARSETALIAS_CID);
- 
-static const eHTMLTags gWatchTags[] = 
-{ eHTMLTag_meta,
-  eHTMLTag_unknown
-};
-
-//-------------------------------------------------------------------------
-nsMetaCharsetObserver::nsMetaCharsetObserver()
-{
-  bMetaCharsetObserverStarted = PR_FALSE;
-  nsresult res;
-  mAlias = nsnull;
-  nsCOMPtr<nsICharsetAlias> calias(do_GetService(kCharsetAliasCID, &res));
-  if(NS_SUCCEEDED(res)) {
-     mAlias = calias;
-  }
-}
-//-------------------------------------------------------------------------
-nsMetaCharsetObserver::~nsMetaCharsetObserver()
-{
-}
-
-//-------------------------------------------------------------------------
-NS_IMPL_ADDREF ( nsMetaCharsetObserver )
-NS_IMPL_RELEASE ( nsMetaCharsetObserver )
-
-// Use the new scheme
-NS_IMPL_QUERY_INTERFACE4(nsMetaCharsetObserver, 
-                         nsIElementObserver, 
-                         nsIObserver, 
-                         nsIMetaCharsetService, 
-                         nsISupportsWeakReference)
-
-//-------------------------------------------------------------------------
-NS_IMETHODIMP nsMetaCharsetObserver::Notify(
-                     PRUint32 aDocumentID, 
-                     const PRUnichar* aTag, 
-                     PRUint32 numOfAttributes, 
-                     const PRUnichar* nameArray[], 
-                     const PRUnichar* valueArray[])
-{
-  
-    if(!nsDependentString(aTag).LowerCaseEqualsLiteral("meta")) 
-        return NS_ERROR_ILLEGAL_VALUE;
-    else
-        return Notify(aDocumentID, numOfAttributes, nameArray, valueArray);
-}
-//-------------------------------------------------------------------------
-NS_IMETHODIMP nsMetaCharsetObserver::Notify(
-                     PRUint32 aDocumentID, 
-                     eHTMLTags aTag, 
-                     PRUint32 numOfAttributes, 
-                     const PRUnichar* nameArray[], 
-                     const PRUnichar* valueArray[])
-{
-    if(eHTMLTag_meta != aTag) 
-        return NS_ERROR_ILLEGAL_VALUE;
-    else 
-        return Notify(aDocumentID, numOfAttributes, nameArray, valueArray);
-}
-
-NS_IMETHODIMP nsMetaCharsetObserver::Notify(
-                     PRUint32 aDocumentID, 
-                     PRUint32 numOfAttributes, 
-                     const PRUnichar* nameArray[], 
-                     const PRUnichar* valueArray[])
-{
-   nsDeque keys(0);
-   nsDeque values(0);
-   PRUint32 i;
-   for(i=0;i<numOfAttributes;i++)
-   {
-       keys.Push((void*)nameArray[i]);
-       values.Push((void*)valueArray[i]);
-   }
-   return NS_OK;//Notify((nsISupports*)aDocumentID, &keys, &values);
-}
-NS_IMETHODIMP nsMetaCharsetObserver::Notify(
-                     nsISupports* aDocShell,
-                     nsISupports* aChannel,
-                     const PRUnichar* aTag, 
-                     const nsTArray<nsString>* keys, 
-                     const nsTArray<nsString>* values,
-                     const PRUint32 aFlags)
-{
-  nsresult result = NS_OK;
-  // bug 125317 - document.write content is already an unicode content.
-  if (!(aFlags & nsIElementObserver::IS_DOCUMENT_WRITE)) {
-    if(!nsDependentString(aTag).LowerCaseEqualsLiteral("meta")) {
-        result = NS_ERROR_ILLEGAL_VALUE;
-    }
-    else {
-        result = Notify(aDocShell, aChannel, keys, values);
-    }
-  }
-  return result;
-}
-
-#define IS_SPACE_CHARS(ch)  (ch == ' ' || ch == '\b' || ch == '\r' || ch == '\n')
-
-NS_IMETHODIMP nsMetaCharsetObserver::Notify(
-                    nsISupports* aDocShell,
-                    nsISupports* aChannel,
-                    const nsTArray<nsString>* keys, 
-                    const nsTArray<nsString>* values)
-{
-    NS_PRECONDITION(keys!=nsnull && values!=nsnull,"Need key-value pair");
-
-    PRUint32 numOfAttributes = keys->Length();
-    NS_ASSERTION( numOfAttributes == values->Length(), "size mismatch");
-    nsresult res=NS_OK;
-#ifdef DEBUG
-
-    PRUnichar Uxcommand[]={'X','_','C','O','M','M','A','N','D','\0'};
-    PRUnichar UcharsetSource[]={'c','h','a','r','s','e','t','S','o','u','r','c','e','\0'};
-    PRUnichar Ucharset[]={'c','h','a','r','s','e','t','\0'};
-    
-    NS_ASSERTION(numOfAttributes >= 3, "should have at least 3 private attribute");
-    NS_ASSERTION(0==nsCRT::strcmp(Uxcommand,(keys->ElementAt(numOfAttributes-1)).get()),"last name should be 'X_COMMAND'" );
-    NS_ASSERTION(0==nsCRT::strcmp(UcharsetSource,(keys->ElementAt(numOfAttributes-2)).get()),"2nd last name should be 'charsetSource'" );
-    NS_ASSERTION(0==nsCRT::strcmp(Ucharset,(keys->ElementAt(numOfAttributes-3)).get()),"3rd last name should be 'charset'" );
-
-#endif
-    NS_ASSERTION(mAlias, "Didn't get nsICharsetAlias in constructor");
-
-    if(nsnull == mAlias)
-      return NS_ERROR_ABORT;
-
-    // we need at least 5 - HTTP-EQUIV, CONTENT and 3 private
-    if(numOfAttributes >= 5 ) 
-    {
-      const nsString& srcStr =  values->ElementAt(numOfAttributes-2);
-      PRInt32 err;
-      PRInt32  src = srcStr.ToInteger(&err);
-      // if we cannot convert the string into PRInt32, return error
-      NS_ASSERTION(NS_SUCCEEDED(err), "cannot get charset source");
-      if(NS_FAILED(err))
-          return NS_ERROR_ILLEGAL_VALUE;
-
-      if(kCharsetFromMetaTag <= src)
-          return NS_OK; // current charset has higher priority. don't bother to do the following
-
-      const PRUnichar *httpEquivValue=nsnull;
-      const PRUnichar *contentValue=nsnull;
-      const PRUnichar *charsetValue=nsnull;
-
-      for (PRUint32 i = 0; i < numOfAttributes - 3; i++)
-      {
-        const PRUnichar *keyStr;
-        keyStr = keys->ElementAt(i).get();
-
-        //Change 3.190 in nsHTMLTokens.cpp allow  ws/tab/cr/lf exist before 
-        // and after text value, this need to be skipped before comparison
-        while(IS_SPACE_CHARS(*keyStr)) 
-          keyStr++;
-
-        if(Substring(keyStr, keyStr+10).LowerCaseEqualsLiteral("http-equiv"))
-              httpEquivValue = values->ElementAt(i).get();
-        else if(Substring(keyStr, keyStr+7).LowerCaseEqualsLiteral("content"))
-              contentValue = values->ElementAt(i).get();
-        else if (Substring(keyStr, keyStr+7).LowerCaseEqualsLiteral("charset"))
-              charsetValue = values->ElementAt(i).get();
-      }
-      NS_NAMED_LITERAL_STRING(contenttype, "Content-Type");
-      NS_NAMED_LITERAL_STRING(texthtml, "text/html");
-
-      if(nsnull == httpEquivValue || nsnull == contentValue)
-        return NS_OK;
-
-      while(IS_SPACE_CHARS(*httpEquivValue))
-        ++httpEquivValue;
-      // skip opening quote
-      if (*httpEquivValue == '\'' || *httpEquivValue == '\"')
-        ++httpEquivValue;
-
-      while(IS_SPACE_CHARS(*contentValue))
-        ++contentValue;
-      // skip opening quote
-      if (*contentValue == '\'' || *contentValue == '\"')
-        ++contentValue;
-
-      if(
-         Substring(httpEquivValue,
-                   httpEquivValue+contenttype.Length()).Equals(contenttype,
-                                                               nsCaseInsensitiveStringComparator())
-         &&
-         Substring(contentValue,
-                   contentValue+texthtml.Length()).Equals(texthtml,
-                                                          nsCaseInsensitiveStringComparator())
-        )
-      {
-
-         nsCAutoString newCharset;
-
-         if (nsnull == charsetValue) 
-         {
-           nsAutoString contentPart1(contentValue+9); // after "text/html"
-           PRInt32 start = contentPart1.RFind("charset=", PR_TRUE ) ;
-           PRInt32 end = contentPart1.Length();
-           if(kNotFound != start)
-           {
-             start += 8; // 8 = "charset=".length 
-             while (start < end && contentPart1.CharAt(start) == PRUnichar(' '))
-               ++start;
-             if (start < end) {
-               end = contentPart1.FindCharInSet("\'\"; ", start);
-               if(kNotFound == end ) 
-                 end = contentPart1.Length();
-               NS_ASSERTION(end>=start, "wrong index");
-               LossyCopyUTF16toASCII(Substring(contentPart1, start, end-start),
-                                     newCharset);
-             }
-           } 
-         }
-         else   
-         {
-             LossyCopyUTF16toASCII(nsDependentString(charsetValue), newCharset);
-         } 
-
-         nsCAutoString charsetString;
-         charsetString.AssignWithConversion(values->ElementAt(numOfAttributes-3));
-         
-         if (!newCharset.IsEmpty())
-         {    
-             if(! newCharset.Equals(charsetString, nsCaseInsensitiveCStringComparator()))
-             {
-                 PRBool same = PR_FALSE;
-                 nsresult res2 = mAlias->Equals( newCharset, charsetString , &same);
-                 if(NS_SUCCEEDED(res2) && (! same))
-                 {
-                     nsCAutoString preferred;
-                     res2 = mAlias->GetPreferred(newCharset, preferred);
-                     if(NS_SUCCEEDED(res2))
-                     {
-                        // following charset should have been detected by parser
-                        if (!preferred.EqualsLiteral("UTF-16") &&
-                            !preferred.EqualsLiteral("UTF-16BE") &&
-                            !preferred.EqualsLiteral("UTF-16LE") &&
-                            !preferred.EqualsLiteral("UTF-32") &&
-                            !preferred.EqualsLiteral("UTF-32BE") &&
-                            !preferred.EqualsLiteral("UTF-32LE")) {
-                          // Propagate the error message so that the parser can
-                          // shutdown correctly. - Ref. Bug 96440
-                          res = NotifyDocShell(aDocShell,
-                                               aChannel,
-                                               preferred.get(),
-                                               kCharsetFromMetaTag);
-                        }
-                     } // if(NS_SUCCEEDED(res)
-                 }
-             }
-             else {
-               res = NS_HTMLPARSER_VALID_META_CHARSET;
-             } // if EqualIgnoreCase 
-         } // if !newCharset.IsEmpty()
-      } // if
-    }
-    else
-    {
-      nsAutoString compatCharset;
-      if (NS_SUCCEEDED(GetCharsetFromCompatibilityTag(keys, values, compatCharset)))
-      {
-        if (!compatCharset.IsEmpty()) {
-          res = NotifyDocShell(aDocShell,
-                               aChannel,
-                               NS_ConvertUTF16toUTF8(compatCharset).get(), 
-                               kCharsetFromMetaTag);
-        }
-      }
-    }
-    return res;
-}
-
-//-------------------------------------------------------------------------
-NS_IMETHODIMP nsMetaCharsetObserver::GetCharsetFromCompatibilityTag(
-                     const nsTArray<nsString>* keys, 
-                     const nsTArray<nsString>* values, 
-                     nsAString& aCharset)
-{
-    if (!mAlias)
-        return NS_ERROR_ABORT;
-
-    aCharset.Truncate(0);
-    nsresult res = NS_OK;
-
-
-    // support for non standard case for compatibility
-    // e.g. <META charset="ISO-8859-1">
-    PRUint32 numOfAttributes = keys->Length();
-    if ((numOfAttributes >= 3) &&
-        (keys->ElementAt(0).LowerCaseEqualsLiteral("charset")))
-    {
-      const nsString& srcStr = values->ElementAt(numOfAttributes-2);
-      PRInt32 err;
-      PRInt32  src = srcStr.ToInteger(&err);
-      // if we cannot convert the string into PRInt32, return error
-      if (NS_FAILED(err))
-          return NS_ERROR_ILLEGAL_VALUE;
-      
-      // current charset have a lower priority
-      if (kCharsetFromMetaTag > src)
-      {
-          nsCAutoString newCharset;
-          newCharset.AssignWithConversion(values->ElementAt(0).get());
-          
-          nsCAutoString preferred;
-          res = mAlias->GetPreferred(newCharset,
-                                     preferred);
-          if (NS_SUCCEEDED(res))
-          {
-              // compare against the current charset, 
-              // also some charsets which should have been found in
-              // the BOM detection.
-              const nsString& currentCharset = values->ElementAt(numOfAttributes-3);
-              if (!preferred.Equals(NS_LossyConvertUTF16toASCII(currentCharset)) &&
-                  !preferred.EqualsLiteral("UTF-16") &&
-                  !preferred.EqualsLiteral("UTF-16BE") &&
-                  !preferred.EqualsLiteral("UTF-16LE") &&
-                  !preferred.EqualsLiteral("UTF-32") &&
-                  !preferred.EqualsLiteral("UTF-32BE") &&
-                  !preferred.EqualsLiteral("UTF-32LE"))
-                  AppendASCIItoUTF16(preferred, aCharset);
-          }
-      }
-    }
-
-  return res;
-}
-
-//-------------------------------------------------------------------------
-NS_IMETHODIMP nsMetaCharsetObserver::Observe(nsISupports *aSubject,
-                            const char *aTopic,
-                               const PRUnichar *aData) 
-{
-  nsresult rv = NS_OK;
-  if (!nsCRT::strcmp(aTopic, "parser-service-start")) {
-    rv = Start();
-  }
-  return rv;
-}
-
-//-------------------------------------------------------------------------
-NS_IMETHODIMP nsMetaCharsetObserver::Start() 
-{
-  nsresult rv = NS_OK;
-
-  if (!bMetaCharsetObserverStarted)  {
-    bMetaCharsetObserverStarted = PR_TRUE;
-
-    nsCOMPtr<nsIParserService> parserService(do_GetService(NS_PARSERSERVICE_CONTRACTID, &rv));
-
-    if (NS_FAILED(rv))
-      return rv;
-
-    rv = parserService->RegisterObserver(this,
-                                         NS_LITERAL_STRING("text/html"),
-                                         gWatchTags);
-  }
-
-  return rv;
-}
-//-------------------------------------------------------------------------
-NS_IMETHODIMP nsMetaCharsetObserver::End() 
-{
-  nsresult rv = NS_OK;
-  if (bMetaCharsetObserverStarted)  {
-    bMetaCharsetObserverStarted = PR_FALSE;
-
-    nsCOMPtr<nsIParserService> parserService(do_GetService(NS_PARSERSERVICE_CONTRACTID, &rv));
-
-    if (NS_FAILED(rv))
-      return rv;
-    
-    rv = parserService->UnregisterObserver(this, NS_LITERAL_STRING("text/html"));
-  }
-  return rv;
-}
-//========================================================================== 
-
-
-
-

deleted file mode 100644
--- a/intl/chardet/src/nsMetaCharsetObserver.h
+++ /dev/null
@@ -1,112 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla Public License Version
- * 1.1 (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- * http://www.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either of the GNU General Public License Version 2 or later (the "GPL"),
- * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * 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 ***** */
-#ifndef nsMetaCharsetObserverFactory_h__
-#define nsMetaCharsetObserverFactory_h__
-
-#include "nsIFactory.h"
-#include "nsIMetaCharsetService.h"
-#include "nsIElementObserver.h"
-#include "nsIObserver.h"
-#include "nsObserverBase.h"
-#include "nsWeakReference.h"
-#include "nsTArray.h"
-
-//========================================================================== 
-//
-// Class declaration for the class 
-//
-//========================================================================== 
-class nsMetaCharsetObserver: public nsIElementObserver, 
-                             public nsIObserver, 
-                             public nsObserverBase,
-                             public nsIMetaCharsetService,
-                             public nsSupportsWeakReference {
-public:
-  nsMetaCharsetObserver();
-  virtual ~nsMetaCharsetObserver();
-
-  /* methode for nsIElementObserver */
-
-  /*
-   *   Subject call observer when the parser hit the tag
-   *   @param aDocumentID- ID of the document
-   *   @param aTag- the tag
-   *   @param numOfAttributes - number of attributes
-   *   @param nameArray - array of name. 
-   *   @param valueArray - array of value
-   */
-  NS_IMETHOD Notify(PRUint32 aDocumentID, eHTMLTags aTag, PRUint32 numOfAttributes, 
-                    const PRUnichar* nameArray[], const PRUnichar* valueArray[]);
-  NS_IMETHOD Notify(PRUint32 aDocumentID, const PRUnichar* aTag, PRUint32 numOfAttributes, 
-                    const PRUnichar* nameArray[], const PRUnichar* valueArray[]);
-
-  NS_IMETHOD Notify(nsISupports* aWebShell, 
-                    nsISupports* aChannel,
-                    const PRUnichar* aTag, 
-                    const nsTArray<nsString>* keys, 
-                    const nsTArray<nsString>* values,
-                    const PRUint32 aFlags);
-
-  NS_DECL_ISUPPORTS
-
-  /* methode for nsIObserver */
-  NS_DECL_NSIOBSERVER
-
-  /* methode for nsIMetaCharsetService */
-  NS_IMETHOD Start();
-  NS_IMETHOD End();
- 
-private:
-
-  NS_IMETHOD Notify(PRUint32 aDocumentID, PRUint32 numOfAttributes, 
-                    const PRUnichar* nameArray[], const PRUnichar* valueArray[]);
-
-  NS_IMETHOD Notify(nsISupports* aWebShell, 
-                    nsISupports* aChannel,
-                    const nsTArray<nsString>* keys, 
-                    const nsTArray<nsString>* values);
-
-  NS_IMETHOD GetCharsetFromCompatibilityTag(const nsTArray<nsString>* keys, 
-                                            const nsTArray<nsString>* values, 
-                                            nsAString& aCharset);
-
-  nsCOMPtr<nsICharsetAlias> mAlias;
-
-  PRBool bMetaCharsetObserverStarted;
-};
-
-#endif // nsMetaCharsetObserverFactory_h__

deleted file mode 100644
--- a/intl/chardet/src/nsXMLEncodingObserver.cpp
+++ /dev/null
@@ -1,235 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla Public License Version
- * 1.1 (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- * http://www.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1999
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *   Pierre Phaneuf <pp@ludusdesign.com>
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either of the GNU General Public License Version 2 or later (the "GPL"),
- * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * 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 "nsICharsetAlias.h"
-#include "nsXMLEncodingObserver.h"
-#include "nsIXMLEncodingService.h"
-#include "nsIElementObserver.h"
-#include "nsIObserver.h"
-#include "nsIObserverService.h"
-#include "nsISupports.h"
-#include "nsCRT.h"
-#include "nsIParser.h"
-#include "pratom.h"
-#include "nsCharDetDll.h"
-#include "nsIServiceManager.h"
-#include "nsObserverBase.h"
-#include "nsWeakReference.h"
-#include "nsReadableUtils.h"
-#include "nsUnicharUtils.h"
-#include "mozilla/Services.h"
-
-static NS_DEFINE_CID(kCharsetAliasCID, NS_CHARSETALIAS_CID);
-
-static const eHTMLTags gTags[] = 
-{ eHTMLTag_instruction,
-  eHTMLTag_unknown
-};
-
-//-------------------------------------------------------------------------
-nsXMLEncodingObserver::nsXMLEncodingObserver()
-{
-  bXMLEncodingObserverStarted = PR_FALSE;
-}
-//-------------------------------------------------------------------------
-nsXMLEncodingObserver::~nsXMLEncodingObserver()
-{
-  // call to end the ObserverService
-  if (bXMLEncodingObserverStarted) {
-    End();
-  }
-}
-
-//-------------------------------------------------------------------------
-NS_IMPL_ADDREF ( nsXMLEncodingObserver )
-NS_IMPL_RELEASE ( nsXMLEncodingObserver )
-
-// Use the new scheme
-NS_IMPL_QUERY_INTERFACE4(nsXMLEncodingObserver, 
-                         nsIElementObserver, 
-                         nsIObserver, 
-                         nsIXMLEncodingService, 
-                         nsISupportsWeakReference)
-
-//-------------------------------------------------------------------------
-NS_IMETHODIMP nsXMLEncodingObserver::Notify(
-                     PRUint32 aDocumentID, 
-                     const PRUnichar* aTag, 
-                     PRUint32 numOfAttributes, 
-                     const PRUnichar* nameArray[], 
-                     const PRUnichar* valueArray[])
-{
-    if(!nsDependentString(aTag).LowerCaseEqualsLiteral("?xml")) 
-        return NS_ERROR_ILLEGAL_VALUE;
-    else
-        return Notify(aDocumentID, numOfAttributes, nameArray, valueArray);
-}
-//-------------------------------------------------------------------------
-NS_IMETHODIMP nsXMLEncodingObserver::Notify(
-                     PRUint32 aDocumentID, 
-                     eHTMLTags aTag, 
-                     PRUint32 numOfAttributes, 
-                     const PRUnichar* nameArray[], 
-                     const PRUnichar* valueArray[])
-{
-    if(eHTMLTag_meta != aTag) 
-        return NS_ERROR_ILLEGAL_VALUE;
-    else 
-        return Notify(aDocumentID, numOfAttributes, nameArray, valueArray);
-}
-//-------------------------------------------------------------------------
-NS_IMETHODIMP nsXMLEncodingObserver::Notify(
-                     PRUint32 aDocumentID, 
-                     PRUint32 numOfAttributes, 
-                     const PRUnichar* nameArray[], 
-                     const PRUnichar* valueArray[])
-{
-
-    nsresult res = NS_OK;
-    PRUint32 i;
-
-    if(numOfAttributes >= 3)
-    {
-      PRBool bGotCurrentCharset=PR_FALSE;
-      PRBool bGotCurrentCharsetSource = PR_FALSE;
-      PRBool bGotEncoding = PR_FALSE;
-
-      nsCAutoString currentCharset(NS_LITERAL_CSTRING("unknown"));
-      nsAutoString charsetSourceStr(NS_LITERAL_STRING("unknown"));
-      nsCAutoString encoding(NS_LITERAL_CSTRING("unknown"));
-
-      for(i=0; i < numOfAttributes; i++) 
-      {
-         if(0==nsCRT::strcmp(nameArray[i], NS_LITERAL_STRING("charset").get())) 
-         {
-           bGotCurrentCharset = PR_TRUE;
-           LossyCopyUTF16toASCII(nsDependentString(valueArray[i]), currentCharset);
-         } else if(0==nsCRT::strcmp(nameArray[i], NS_LITERAL_STRING("charsetSource").get())) {
-           bGotCurrentCharsetSource = PR_TRUE;
-           charsetSourceStr = valueArray[i];
-         } else if(nsDependentString(nameArray[i]).LowerCaseEqualsLiteral("encoding")) { 
-           bGotEncoding = PR_TRUE;
-           LossyCopyUTF16toASCII(nsDependentString(valueArray[i]), encoding);
-         }
-      }
-
-      // if we cannot find currentCharset or currentCharsetSource
-      // return error.
-      if( ! (bGotCurrentCharset && bGotCurrentCharsetSource))
-      {
-         return NS_ERROR_ILLEGAL_VALUE;
-      }
-
-      PRInt32 err;
-      PRInt32 charsetSourceInt = charsetSourceStr.ToInteger(&err);
-
-      // if we cannot convert the string into PRInt32, return error
-      if(NS_FAILED(err))
-         return NS_ERROR_ILLEGAL_VALUE;
-
-      PRInt32 currentCharsetSource = charsetSourceInt;
-
-      if(kCharsetFromMetaTag > currentCharsetSource)
-      {
-           if(! encoding.Equals(currentCharset)) 
-           {
-              nsCOMPtr<nsICharsetAlias> calias = do_GetService(kCharsetAliasCID, &res);
-               if(NS_SUCCEEDED(res) && (nsnull != calias) ) 
-               {
-                    PRBool same = PR_FALSE;
-                    res = calias->Equals( encoding, currentCharset, &same);
-                    if(NS_SUCCEEDED(res) && (! same))
-                    {
-                          nsCAutoString preferred;
-                          res = calias->GetPreferred(encoding,
-                                                     preferred);
-                          if(NS_SUCCEEDED(res))
-                          {
-                            res = NotifyDocShell(0,0, preferred.get(), kCharsetFromMetaTag );
-                            return res;
-                          } // if check for GetPreferred
-                    } // if check res for Equals
-                } // if check res for GetService
-            } // if Equals
-       } // if 
-    } // if 
-
-    return NS_OK;
-}
-
-//-------------------------------------------------------------------------
-NS_IMETHODIMP nsXMLEncodingObserver::Observe(nsISupports*, const char*, const PRUnichar*) 
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-//-------------------------------------------------------------------------
-NS_IMETHODIMP nsXMLEncodingObserver::Start() 
-{
-    nsresult res = NS_OK;
-
-    if (bXMLEncodingObserverStarted) 
-      return res;
-
-    nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
-    if (!obs)
-      return NS_ERROR_FAILURE;
-
-    res = obs->AddObserver(this, "xmlparser", PR_TRUE);
-
-    bXMLEncodingObserverStarted = PR_TRUE;
-
-    return res;
-}
-//-------------------------------------------------------------------------
-NS_IMETHODIMP nsXMLEncodingObserver::End() 
-{
-    nsresult res = NS_OK;
-    
-    if (!bXMLEncodingObserverStarted)
-      return res;
-
-    nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
-    if (!obs)
-      return NS_ERROR_FAILURE;
-
-    res = obs->RemoveObserver(this, "xmlparser");
-
-    bXMLEncodingObserverStarted = PR_FALSE;
-
-    return res;
-}
-

deleted file mode 100644
--- a/intl/chardet/src/nsXMLEncodingObserver.h
+++ /dev/null
@@ -1,96 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla Public License Version
- * 1.1 (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- * http://www.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either of the GNU General Public License Version 2 or later (the "GPL"),
- * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * 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 ***** */
-#ifndef nsXMLEncodingObserverFactory_h__
-#define nsXMLEncodingObserverFactory_h__
-
-#include "nsIFactory.h"
-#include "nsIXMLEncodingService.h"
-#include "nsIElementObserver.h"
-#include "nsIObserver.h"
-#include "nsIObserverService.h"
-#include "nsObserverBase.h"
-#include "nsWeakReference.h"
-#include "nsTArray.h"
-
-class nsXMLEncodingObserver: public nsIElementObserver, 
-                             public nsIObserver, 
-                             public nsObserverBase,
-                             public nsIXMLEncodingService,
-                             public nsSupportsWeakReference {
-public:
-  nsXMLEncodingObserver();
-  virtual ~nsXMLEncodingObserver();
-
-  /* methode for nsIElementObserver */
-
-  /*
-   *   Subject call observer when the parser hit the tag
-   *   @param aDocumentID- ID of the document
-   *   @param aTag- the tag
-   *   @param numOfAttributes - number of attributes
-   *   @param nameArray - array of name. 
-   *   @param valueArray - array of value
-   */
-  NS_IMETHOD Notify(PRUint32 aDocumentID, eHTMLTags aTag, PRUint32 numOfAttributes, 
-                    const PRUnichar* nameArray[], const PRUnichar* valueArray[]);
-  NS_IMETHOD Notify(PRUint32 aDocumentID, const PRUnichar* aTag, PRUint32 numOfAttributes, 
-                    const PRUnichar* nameArray[], const PRUnichar* valueArray[]);
-  NS_IMETHOD Notify(nsISupports* aDocShell,
-                    nsISupports* aChannel,
-                    const PRUnichar* aTag, 
-                    const nsTArray<nsString>* keys, 
-                    const nsTArray<nsString>* values,
-                    const PRUint32 aFlags)
-  { return NS_ERROR_NOT_IMPLEMENTED; }
-
-  NS_DECL_ISUPPORTS
-
-  /* methode for nsIObserver */
-  NS_DECL_NSIOBSERVER
-
-  /* methode for nsIXMLEncodingService */
-  NS_IMETHOD Start();
-  NS_IMETHOD End();
-
-private:
-  NS_IMETHOD Notify(PRUint32 aDocumentID, PRUint32 numOfAttributes, 
-                    const PRUnichar* nameArray[], const PRUnichar* valueArray[]);
-
-  PRBool bXMLEncodingObserverStarted;
-};
-
-#endif // nsXMLEncodingObserverFactory_h__

--- a/intl/locale/src/nsLocale.cpp
+++ b/intl/locale/src/nsLocale.cpp
@@ -58,59 +58,16 @@ nsLocale::nsLocale(void)
 :  fHashtable(nsnull), fCategoryCount(0)
 {
   fHashtable = PL_NewHashTable(LOCALE_HASH_SIZE,&nsLocale::Hash_HashFunction,
                                &nsLocale::Hash_CompareNSString,
                                &nsLocale::Hash_CompareNSString, NULL, NULL);
   NS_ASSERTION(fHashtable, "nsLocale: failed to allocate PR_Hashtable");
 }
 
-nsLocale::nsLocale(nsLocale* other) : fHashtable(nsnull), fCategoryCount(0)
-{
-  fHashtable = PL_NewHashTable(LOCALE_HASH_SIZE,&nsLocale::Hash_HashFunction,
-                               &nsLocale::Hash_CompareNSString,
-                               &nsLocale::Hash_CompareNSString, NULL, NULL);
-  NS_ASSERTION(fHashtable, "nsLocale: failed to allocate PR_Hashtable");
-
-  //
-  // enumerate Hash and copy
-  //
-  PL_HashTableEnumerateEntries(other->fHashtable, 
-                               &nsLocale::Hash_EnumerateCopy, fHashtable);
-}
-
-
-nsLocale::nsLocale(const nsTArray<nsString>& categoryList, 
-                   const nsTArray<nsString>& valueList) 
-                  : fHashtable(NULL), fCategoryCount(0)
-{
-  PRUnichar* key, *value;
-
-  fHashtable = PL_NewHashTable(LOCALE_HASH_SIZE,&nsLocale::Hash_HashFunction,
-                               &nsLocale::Hash_CompareNSString,
-                               &nsLocale::Hash_CompareNSString,
-                               NULL, NULL);
-  NS_ASSERTION(fHashtable, "nsLocale: failed to allocate PR_Hashtable");
-
-  if (fHashtable)
-  {
-    for(PRUint32 i=0; i < categoryList.Length(); ++i) 
-    {
-      key = ToNewUnicode(categoryList[i]);
-      NS_ASSERTION(key, "nsLocale: failed to allocate internal hash key");
-      value = ToNewUnicode(valueList[i]);
-      NS_ASSERTION(value, "nsLocale: failed to allocate internal hash value");
-      if (!PL_HashTableAdd(fHashtable,key,value)) {
-          nsMemory::Free(key);
-          nsMemory::Free(value);
-      }
-    }
-  }
-}
-
 nsLocale::~nsLocale(void)
 {
   // enumerate all the entries with a delete function to
   // safely delete all the keys and values
   PL_HashTableEnumerateEntries(fHashtable, &nsLocale::Hash_EnumerateDelete,
                                NULL);
 
   PL_HashTableDestroy(fHashtable);
@@ -181,30 +138,8 @@ nsLocale::Hash_EnumerateDelete(PLHashEnt
 {
   // delete an entry
   nsMemory::Free((PRUnichar *)he->key);
   nsMemory::Free((PRUnichar *)he->value);
 
   return (HT_ENUMERATE_NEXT | HT_ENUMERATE_REMOVE);
 }
 
-PRIntn
-nsLocale::Hash_EnumerateCopy(PLHashEntry *he, PRIntn hashIndex, void* arg)
-{
-  PRUnichar* newKey = ToNewUnicode(nsDependentString((PRUnichar *)he->key));
-  if (!newKey) 
-    return HT_ENUMERATE_STOP;
-
-  PRUnichar* newValue = ToNewUnicode(nsDependentString((PRUnichar *)he->value));
-  if (!newValue) {
-    nsMemory::Free(newKey);
-    return HT_ENUMERATE_STOP;
-  }
-
-  if (!PL_HashTableAdd((PLHashTable*)arg, newKey, newValue)) {
-    nsMemory::Free(newKey);
-    nsMemory::Free(newValue);
-    return HT_ENUMERATE_STOP;
-  }
-
-  return (HT_ENUMERATE_NEXT);
-}
-

--- a/intl/locale/src/nsLocale.h
+++ b/intl/locale/src/nsLocale.h
@@ -58,31 +58,28 @@
 #include "plhash.h"
 
 class nsLocale : public nsILocale {
 	friend class nsLocaleService;
 	NS_DECL_ISUPPORTS
 
 public:
 	nsLocale(void);
-	nsLocale(const nsTArray<nsString>& categoryList, const nsTArray<nsString>& valueList);
-	nsLocale(nsLocale* other);
 	virtual ~nsLocale(void);
 	
 	/* Declare methods from nsILocale */
 	NS_DECL_NSILOCALE
 
 protected:
 	
 	NS_IMETHOD AddCategory(const nsAString& category, const nsAString& value);
 
 	static PLHashNumber Hash_HashFunction(const void* key);
 	static PRIntn Hash_CompareNSString(const void* s1, const void* s2);
 	static PRIntn Hash_EnumerateDelete(PLHashEntry *he, PRIntn hashIndex, void *arg);
-	static PRIntn Hash_EnumerateCopy(PLHashEntry *he, PRIntn hashIndex, void *arg);
 
 	PLHashTable*	fHashtable;
 	PRUint32		fCategoryCount;
 
 };
 
 
 #endif

--- a/intl/lwbrk/public/nsIWordBreaker.h
+++ b/intl/lwbrk/public/nsIWordBreaker.h
@@ -61,16 +61,13 @@ public:
   virtual PRBool BreakInBetween(const PRUnichar* aText1 , PRUint32 aTextLen1,
                                 const PRUnichar* aText2 ,
                                 PRUint32 aTextLen2) = 0;
   virtual nsWordRange FindWord(const PRUnichar* aText1 , PRUint32 aTextLen1,
                                PRUint32 aOffset) = 0;
   virtual PRInt32 NextWord(const PRUnichar* aText, PRUint32 aLen, 
                            PRUint32 aPos) = 0;
                            
-  virtual PRInt32 PrevWord(const PRUnichar* aText, PRUint32 aLen, 
-                           PRUint32 aPos) = 0;
-
 };
 
 NS_DEFINE_STATIC_IID_ACCESSOR(nsIWordBreaker, NS_IWORDBREAKER_IID)
 
 #endif  /* nsIWordBreaker_h__ */

--- a/intl/lwbrk/src/nsSampleWordBreaker.cpp
+++ b/intl/lwbrk/src/nsSampleWordBreaker.cpp
@@ -177,36 +177,8 @@ PRInt32 nsSampleWordBreaker::NextWord(
   {
 	// need to call Thai word breaker from here
 	// we should pass the whole Thai segment to the thai word breaker to find a shorter answer
   }
   if (cur == aLen)
     return NS_WORDBREAKER_NEED_MORE_TEXT;
   return cur;
 }
-
-PRInt32 nsSampleWordBreaker::PrevWord(
-  const PRUnichar* aText, PRUint32 aLen, PRUint32 aPos) 
-{
-  PRInt8 c1, c2;
-  PRUint32 cur = aPos;
-  if (cur == aLen) {
-    if (cur == 0)
-      return NS_WORDBREAKER_NEED_MORE_TEXT;
-    --cur;
-  }
-  c1 = this->GetClass(aText[cur]);
-
-  for(; cur > 0; cur--)
-  {
-     c2 = this->GetClass(aText[cur-1]);
-     if(c2 != c1)
-       break;
-  }
-  if(kWbClassThaiLetter == c1)
-  {
-	// need to call Thai word breaker from here
-	// we should pass the whole Thai segment to the thai word breaker to find a shorter answer
-  }
-  if (!cur)
-    return NS_WORDBREAKER_NEED_MORE_TEXT;
-  return cur;
-}

--- a/intl/lwbrk/src/nsSampleWordBreaker.h
+++ b/intl/lwbrk/src/nsSampleWordBreaker.h
@@ -61,15 +61,13 @@ public:
 
   PRBool BreakInBetween(const PRUnichar* aText1 , PRUint32 aTextLen1,
                         const PRUnichar* aText2 , PRUint32 aTextLen2);
   nsWordRange FindWord(const PRUnichar* aText1 , PRUint32 aTextLen1,
                        PRUint32 aOffset);
 
   PRInt32 NextWord(const PRUnichar* aText, PRUint32 aLen, PRUint32 aPos);
 
-  PRInt32 PrevWord(const PRUnichar* aText, PRUint32 aLen, PRUint32 aPos);
-
 protected:
   PRUint8  GetClass(PRUnichar aChar);
 };
 
 #endif  /* nsSampleWordBreaker_h__ */

--- a/intl/uconv/native/nsINativeUConvService.idl
+++ b/intl/uconv/native/nsINativeUConvService.idl
@@ -38,15 +38,14 @@
 
 #include "nsISupports.idl"
 
 /*
  * Returns an object that implements the following interfaces:
  *  
  *  nsIUnicodeDecoder 
  *  nsIUnicodeEncoder 
- *  nsICharRepresentable
  */
 [uuid(c60097ba-c79d-461b-9116-80a66404c0b0)]
 interface nsINativeUConvService : nsISupports
 {
   nsISupports getNativeConverter(in string from, in string to);
 };

--- a/intl/uconv/native/nsNativeUConvService.cpp
+++ b/intl/uconv/native/nsNativeUConvService.cpp
@@ -39,30 +39,28 @@
 #ifdef MOZ_USE_NATIVE_UCONV
 #include "nsString.h"
 #include "nsIGenericFactory.h"
 
 #include "nsINativeUConvService.h"
 
 #include "nsIUnicodeDecoder.h"
 #include "nsIUnicodeEncoder.h"
-#include "nsICharRepresentable.h"
 
 #include "nsNativeUConvService.h"
 #include "nsAutoPtr.h"
 
 #include <nl_types.h> // CODESET
 #include <langinfo.h> // nl_langinfo
 #include <iconv.h>    // iconv_open, iconv, iconv_close
 #include <errno.h>
 
 
 class IConvAdaptor : public nsIUnicodeDecoder, 
-                     public nsIUnicodeEncoder, 
-                     public nsICharRepresentable
+                     public nsIUnicodeEncoder 
 {
 public:
     IConvAdaptor();
     virtual ~IConvAdaptor();
     
     nsresult Init(const char* from, const char* to);
     
     NS_DECL_ISUPPORTS
@@ -98,18 +96,16 @@ public:
                             PRInt32 * aDestLength);
     
     // defined by the Decoder:  NS_IMETHOD Reset();
     
     NS_IMETHOD SetOutputErrorBehavior(PRInt32 aBehavior, 
                                       nsIUnicharEncoder * aEncoder, 
                                       PRUnichar aChar);
     
-    NS_IMETHOD FillInfo(PRUint32* aInfo);
-    
     
 private:
     nsresult ConvertInternal(void * aSrc, 
                              PRInt32 * aSrcLength, 
                              PRInt32 aSrcCharSize,
                              void * aDest, 
                              PRInt32 * aDestLength,
                              PRInt32 aDestCharSize);
@@ -119,20 +115,19 @@ private:
     PRBool    mReplaceOnError;
     PRUnichar mReplaceChar;
 
 #ifdef DEBUG
     nsCString mFrom, mTo;
 #endif
 };
 
-NS_IMPL_ISUPPORTS3(IConvAdaptor, 
+NS_IMPL_ISUPPORTS2(IConvAdaptor, 
                    nsIUnicodeEncoder, 
-                   nsIUnicodeDecoder,
-                   nsICharRepresentable)
+                   nsIUnicodeDecoder)
 
 IConvAdaptor::IConvAdaptor()
 {
     mConverter = 0;
     mReplaceOnError = PR_FALSE;
 }
 
 IConvAdaptor::~IConvAdaptor()
@@ -276,26 +271,16 @@ IConvAdaptor::SetOutputErrorBehavior(PRI
         mReplaceChar = aChar;
         return NS_OK;
     }
 
     NS_WARNING("Uconv Error Behavior not support");
     return NS_ERROR_FAILURE;
 }
 
-nsresult 
-IConvAdaptor::FillInfo(PRUint32* aInfo)
-{
-#ifdef DEBUG
-    printf(" * IConvAdaptor - FillInfo called\n");
-#endif
-    *aInfo = 0;
-    return NS_OK;
-}
-
 
 nsresult 
 IConvAdaptor::ConvertInternal(void * aSrc, 
                              PRInt32 * aSrcLength, 
                              PRInt32 aSrcCharSize,
                              void * aDest, 
                              PRInt32 * aDestLength,
                              PRInt32 aDestCharSize)

--- a/intl/uconv/native/nsWinCEUConvService.cpp
+++ b/intl/uconv/native/nsWinCEUConvService.cpp
@@ -34,17 +34,16 @@
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include <windows.h>
 
 #include "nsNativeUConvService.h"
 #include "nsIUnicodeDecoder.h"
 #include "nsIUnicodeEncoder.h"
-#include "nsICharRepresentable.h"
 #include "nsIPlatformCharset.h"
 #include "nsIServiceManager.h"
 
 #include "nsUCSupport.h"
 #include "nsUTF8ToUnicode.h"
 #include "nsUnicodeToUTF8.h"
 
 #ifdef ALERT_DBG
@@ -69,18 +68,17 @@ void DisplayLastError(const char * msg)
     default:
       MessageBox(0, "other...", msg, flags);
     }
 }
 #endif
 
 
 class WinCEUConvAdapter : public nsIUnicodeDecoder,
-                          public nsIUnicodeEncoder,
-                          public nsICharRepresentable
+                          public nsIUnicodeEncoder
 {
 public:
   
   WinCEUConvAdapter();
   virtual ~WinCEUConvAdapter();
   
   nsresult Init(const char* from, const char* to);
   
@@ -116,25 +114,22 @@ public:
                           PRInt32 * aDestLength);
   
   // defined by the Decoder:  NS_IMETHOD Reset();
   
   NS_IMETHOD SetOutputErrorBehavior(PRInt32 aBehavior, 
                                     nsIUnicharEncoder * aEncoder, 
                                     PRUnichar aChar);
   
-  NS_IMETHOD FillInfo(PRUint32* aInfo);
-  
   PRUint32 mCodepage;
 };
 
-NS_IMPL_ISUPPORTS3(WinCEUConvAdapter,
+NS_IMPL_ISUPPORTS2(WinCEUConvAdapter,
                    nsIUnicodeDecoder,
-                   nsIUnicodeEncoder,
-                   nsICharRepresentable)
+                   nsIUnicodeEncoder)
 
 WinCEUConvAdapter::WinCEUConvAdapter()
 {
   mCodepage = -1;
 }
 
 WinCEUConvAdapter::~WinCEUConvAdapter()
 {
@@ -396,22 +391,16 @@ WinCEUConvAdapter::GetMaxLength(const PR
 NS_IMETHODIMP
 WinCEUConvAdapter::SetOutputErrorBehavior(PRInt32 aBehavior, 
                                           nsIUnicharEncoder * aEncoder, 
                                           PRUnichar aChar)
 {
   return NS_OK;
 }
 
-NS_IMETHODIMP
-WinCEUConvAdapter::FillInfo(PRUint32* aInfo)
-{
-  return NS_OK;
-}
-
 // NativeUConvService
 
 NS_IMPL_ISUPPORTS1(NativeUConvService, 
                    nsINativeUConvService);
 
 NS_IMETHODIMP 
 NativeUConvService::GetNativeConverter(const char* from,
                                        const char* to,

--- a/intl/uconv/public/Makefile.in
+++ b/intl/uconv/public/Makefile.in
@@ -44,16 +44,15 @@ include $(DEPTH)/config/autoconf.mk
 
 MODULE		= uconv
 
 EXPORTS		= \
 		nsICharsetAlias.h \
 		nsIPlatformCharset.h \
 		nsIUnicodeDecoder.h \
 		nsIUnicodeEncoder.h \
-		nsICharRepresentable.h \
 		uconvutil.h \
 		nsEncoderDecoderUtils.h \
 		nsUConvCID.h \
 		$(NULL)
 
 include $(topsrcdir)/config/rules.mk
 

deleted file mode 100644
--- a/intl/uconv/public/nsICharRepresentable.h
+++ /dev/null
@@ -1,73 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla Public License Version
- * 1.1 (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- * http://www.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is Mozilla Communicator client code.
- *
- * The Initial Developer of the Original Code is
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either of the GNU General Public License Version 2 or later (the "GPL"),
- * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * 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 ***** */
-
-#ifndef nsICharRepresentable_h__
-#define nsICharRepresentable_h__
-
-#include "nscore.h"
-#include "nsISupports.h"
-
-// {A4D9A521-185A-11d3-B3BD-00805F8A6670}
-#define NS_ICHARREPRESENTABLE_IID \
-{ 0xa4d9a521, 0x185a, 0x11d3, { 0xb3, 0xbd, 0x0, 0x80, 0x5f, 0x8a, 0x66, 0x70 } }
-
-
-/* 
-   The following two macro have been duplicate in umap.c. 
-   You need to change both place to make it work 
-*/
-#define IS_REPRESENTABLE(info, c) (((info)[(c) >> 5] >> ((c) & 0x1f)) & 1L)
-#define SET_REPRESENTABLE(info, c)  (info)[(c) >> 5] |= (1L << ((c) & 0x1f))
-#define CLEAR_REPRESENTABLE(info, c)  (info)[(c) >> 5] &= (~(1L << ((c) & 0x1f)))
-
-// number of PRUint32 in the 64Kbit char map
-#define UCS2_MAP_LEN 2048
-
-/**
- */
-class nsICharRepresentable : public nsISupports
-{
-public:
-  NS_DECLARE_STATIC_IID_ACCESSOR(NS_ICHARREPRESENTABLE_IID)
-
-  NS_IMETHOD FillInfo(PRUint32* aInfo) = 0;
-
-};
-
-NS_DEFINE_STATIC_IID_ACCESSOR(nsICharRepresentable, NS_ICHARREPRESENTABLE_IID)
-
-#endif /* nsIUnicodeDecoder_h__ */

--- a/intl/uconv/src/nsUTF8ToUnicode.cpp
+++ b/intl/uconv/src/nsUTF8ToUnicode.cpp
@@ -39,40 +39,16 @@
 #define MOZILLA_SSE_INCLUDE_HEADER_FOR_SSE2
 
 #include "nsUCSupport.h"
 #include "nsUTF8ToUnicode.h"
 #include "mozilla/SSE.h"
 
 #define UNICODE_BYTE_ORDER_MARK    0xFEFF
 
-NS_IMETHODIMP NS_NewUTF8ToUnicode(nsISupports* aOuter,
-                                  const nsIID& aIID,
-                                  void** aResult)
-{
-  if (!aResult) {
-    return NS_ERROR_NULL_POINTER;
-  }
-  if (aOuter) {
-    *aResult = nsnull;
-    return NS_ERROR_NO_AGGREGATION;
-  }
-  nsUTF8ToUnicode * inst = new nsUTF8ToUnicode();
-  if (!inst) {
-    *aResult = nsnull;
-    return NS_ERROR_OUT_OF_MEMORY;
-  }
-  nsresult res = inst->QueryInterface(aIID, aResult);
-  if (NS_FAILED(res)) {
-    *aResult = nsnull;
-    delete inst;
-  }
-  return res;
-}
-
 //----------------------------------------------------------------------
 // Class nsUTF8ToUnicode [implementation]
 
 nsUTF8ToUnicode::nsUTF8ToUnicode()
 : nsBasicDecoderSupport()
 {
   Reset();
 }

--- a/intl/uconv/src/nsUnicodeToUTF8.cpp
+++ b/intl/uconv/src/nsUnicodeToUTF8.cpp
@@ -54,22 +54,16 @@ NS_IMETHODIMP nsUnicodeToUTF8::GetMaxLen
   // But when previous buffer only contains part of the surrogate pair, we 
   // need to complete it here. If the first word in following buffer is not
   // in valid surrogate rang, we need to convert the remaining of last buffer 
   // to 3 bytes.
   *aDestLength = 3*aSrcLength + 3;
   return NS_OK;
 }
 
-NS_IMETHODIMP nsUnicodeToUTF8::FillInfo(PRUint32 *aInfo)
-{
-  memset(aInfo, 0xFF, (0x10000L >> 3));
-  return NS_OK;
-}
-
 NS_IMETHODIMP nsUnicodeToUTF8::Convert(const PRUnichar * aSrc, 
                                 PRInt32 * aSrcLength, 
                                 char * aDest, 
                                 PRInt32 * aDestLength)
 {
   const PRUnichar * src = aSrc;
   const PRUnichar * srcEnd = aSrc + *aSrcLength;
   char * dest = aDest;

--- a/intl/uconv/src/nsUnicodeToUTF8.h
+++ b/intl/uconv/src/nsUnicodeToUTF8.h
@@ -63,18 +63,16 @@ class nsUnicodeToUTF8 : public nsIUnicod
 
 public:
 
   /**
    * Class constructor.
    */
   nsUnicodeToUTF8() {mHighSurrogate = 0;}
 
-  NS_IMETHOD FillInfo(PRUint32* aInfo);
-
   NS_IMETHOD Convert(const PRUnichar * aSrc, 
                      PRInt32 * aSrcLength, 
                      char * aDest, 
                      PRInt32 * aDestLength);
 
   NS_IMETHOD Finish(char * aDest, PRInt32 * aDestLength);
 
   NS_IMETHOD GetMaxLength(const PRUnichar * aSrc, PRInt32 aSrcLength, 

--- a/intl/uconv/tests/nsTestUConv.cpp
+++ b/intl/uconv/tests/nsTestUConv.cpp
@@ -39,26 +39,23 @@
 #include <stdio.h>
 #include <string.h>
 #include "nsXPCOM.h"
 #include "nsIComponentManager.h"
 #include "nsIServiceManager.h"
 #include "nsISupports.h"
 #include "nsICharsetConverterManager.h"
 #include "nsIPlatformCharset.h"
-#include "nsICharRepresentable.h"
 #include "prmem.h"
 #include "nsReadableUtils.h"
 
 
 static NS_DEFINE_CID(kCharsetConverterManagerCID, NS_ICHARSETCONVERTERMANAGER_CID);
 static NS_DEFINE_CID(kPlatformCharsetCID, NS_PLATFORMCHARSET_CID);
 
-//#define TEST_IS_REPRESENTABLE
-
 /**
  * Test program for the Unicode Converters.
  *
  * Error messages format inside of a test.
  *
  * - silent while all is OK.
  * 
  * - "ERROR at T001.easyConversion.Convert() code=0xfffd.\n"
@@ -213,30 +210,16 @@ nsresult testEncoder(nsIUnicodeEncoder *
       return NS_ERROR_UNEXPECTED;
   }
   for (PRInt32 i=0; i<aResLength; i++) if (aRes[i] != dest[i]) {
       printf("ERROR at %s.easy.EncResChar[%d] expected=0x%x result=0x%x.\n", 
           aTestName, i, aRes[i], dest[i]);
       return NS_ERROR_UNEXPECTED;
   }
   
-#ifdef TEST_IS_REPRESENTABLE
-  nsICharRepresentable* rp = nsnull;
-  res = aEnc->QueryInterface(NS_GET_IID(nsICharRepresentable),(void**) &rp);
-  if(NS_SUCCEEDED(res))  {
-    PRUint32 *info= (PRUint32*)PR_Calloc((0x10000 >> 5), 4);
-    rp->FillInfo(info);
-    for(int i=0;i< 0x10000;i++)
-    {
-       if(IS_REPRESENTABLE(info, i)) 
-           printf("%4x\n", i);
-    }
-  }
-#endif
-
   return NS_OK;
 }
 
 /**
  * Decoder test.
  * 
  * This method will test a given converter under a given set of data and some 
  * very stressful conditions.

--- a/intl/uconv/ucvcn/nsGBKConvUtil.cpp
+++ b/intl/uconv/ucvcn/nsGBKConvUtil.cpp
@@ -33,17 +33,16 @@
  * 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 "nsGBKConvUtil.h"
 #include "gbku.h"
 #include "nsCRT.h"
-#include "nsICharRepresentable.h"
 #define MAX_GBK_LENGTH 24066 /* (0xfe-0x80)*(0xfe-0x3f) */
 //--------------------------------------------------------------------
 // nsGBKConvUtil
 //--------------------------------------------------------------------
 
 static PRBool gInitToGBKTable = PR_FALSE;
 static const PRUnichar gGBKToUnicodeTable[MAX_GBK_LENGTH] = {
 #include "cp936map.h"
@@ -144,72 +143,8 @@ void nsGBKConvUtil::InitToGBKTable()
     {
       unicode -= 0x4E00; 
       gUnicodeToGBKTable[unicode] =  (( i / 0x00BF + 0x0081) << 8) | 
                                     ( i % 0x00BF+ 0x0040);
     }
   }
   gInitToGBKTable = PR_TRUE;
 }
-void nsGBKConvUtil::FillInfo( 
-  PRUint32 *aInfo, 
-  PRUint8 aStart1, PRUint8 aEnd1, 
-  PRUint8 aStart2, PRUint8 aEnd2
-)
-{
-  PRUint16 i,j, k;
-  PRUnichar unicode;
-
-  for ( i=aStart1; i<=aEnd1; i++) 
-  {
-    for( j=aStart2; j<=aEnd2; j++)
-    {
-      k = (i - 0x0081)*0x00BF +(j-0x0040);    
-      unicode = gGBKToUnicodeTable[k];
-      NS_ASSERTION(unicode != 0xFFFF, "somehow the table still use 0xffff");
-      if (unicode != UCS2_NO_MAPPING) 
-      {
-        SET_REPRESENTABLE(aInfo, unicode);
-      }               
-    }
-  }                   
-}
-void nsGBKConvUtil::FillGB2312Info( 
-  PRUint32 *aInfo
-)
-{
-  // The following range is coded by looking at the GB2312 standard
-  // and make sure we do not call FillInfo for undefined code point
-  // Symbol
-  // row 1 - 1 range (full)
-  FillInfo(aInfo, 0x21|0x80, 0x21|0x80, 0x21|0x80, 0x7E|0x80);
-  // row 2 - 3 range
-  FillInfo(aInfo, 0x22|0x80, 0x22|0x80, (0x20+17)|0x80, (0x20+66)|0x80);
-  FillInfo(aInfo, 0x22|0x80, 0x22|0x80, (0x20+69)|0x80, (0x20+78)|0x80);
-  FillInfo(aInfo, 0x22|0x80, 0x22|0x80, (0x20+81)|0x80, (0x20+92)|0x80);
-  // row 3 - 1 range (full)
-  FillInfo(aInfo, 0x23|0x80, 0x23|0x80, 0x21|0x80, 0x7E|0x80);
-  // row 4 - 1 range
-  FillInfo(aInfo, 0x24|0x80, 0x24|0x80, (0x20+ 1)|0x80, (0x20+83)|0x80);
-  // row 5 - 1 range
-  FillInfo(aInfo, 0x25|0x80, 0x25|0x80, (0x20+ 1)|0x80, (0x20+86)|0x80);
-  // row 6 - 2 range
-  FillInfo(aInfo, 0x26|0x80, 0x26|0x80, (0x20+ 1)|0x80, (0x20+24)|0x80);
-  FillInfo(aInfo, 0x26|0x80, 0x26|0x80, (0x20+33)|0x80, (0x20+56)|0x80);
-  // row 7
-  FillInfo(aInfo, 0x27|0x80, 0x27|0x80, (0x20+ 1)|0x80, (0x20+33)|0x80);
-  FillInfo(aInfo, 0x27|0x80, 0x27|0x80, (0x20+49)|0x80, (0x20+81)|0x80);
-  // row 8
-  FillInfo(aInfo, 0x28|0x80, 0x28|0x80, (0x20+ 1)|0x80, (0x20+26)|0x80);
-  FillInfo(aInfo, 0x28|0x80, 0x28|0x80, (0x20+36)|0x80, (0x20+73)|0x80);
-  // row 9
-  FillInfo(aInfo, 0x29|0x80, 0x29|0x80, (0x20+ 4)|0x80, (0x20+79)|0x80);
- 
-  // Frequent used Hanzi
-  // 3021-567e
-  FillInfo(aInfo, 0x30|0x80, 0x56|0x80, 0x21|0x80, 0x7E|0x80);
-  // 5721-5779
-  FillInfo(aInfo, 0x57|0x80, 0x57|0x80, 0x21|0x80, 0x79|0x80);
-
-  // Infrequent used Hanzi
-  // 5821-777e
-  FillInfo(aInfo, 0x58|0x80, 0x77|0x80, 0x21|0x80, 0x7E|0x80);
-}

--- a/intl/uconv/ucvcn/nsGBKConvUtil.h
+++ b/intl/uconv/ucvcn/nsGBKConvUtil.h
@@ -41,13 +41,10 @@
 class nsGBKConvUtil {
 public:
   nsGBKConvUtil() {  }
   ~nsGBKConvUtil() { }
   void InitToGBKTable();
   PRUnichar GBKCharToUnicode(char aByte1, char aByte2);
   PRBool UnicodeToGBKChar(PRUnichar aChar, PRBool aToGL, 
                            char* aOutByte1, char* aOutByte2);
-  void FillInfo(PRUint32 *aInfo, PRUint8 aStart1, PRUint8 aEnd1,
-                                 PRUint8 aStart2, PRUint8 aEnd2);
-  void FillGB2312Info(PRUint32 *aInfo);
 };
 #endif /* nsGBKConvUtil_h__ */

--- a/intl/uconv/ucvcn/nsUnicodeToGB2312V2.cpp
+++ b/intl/uconv/ucvcn/nsUnicodeToGB2312V2.cpp
@@ -32,17 +32,16 @@
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * 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 "nsUnicodeToGB2312V2.h"
-#include "nsICharRepresentable.h"
 #include "nsUCvCnDll.h"
 #include "gbku.h"
 
 //----------------------------------------------------------------------
 // Class nsUnicodeToGB2312V2 [implementation]
 nsUnicodeToGB2312V2::nsUnicodeToGB2312V2() :
   nsEncoderSupport(2)
 {
@@ -94,20 +93,8 @@ NS_IMETHODIMP nsUnicodeToGB2312V2::Conve
       res = NS_OK_UENC_MOREOUTPUT;
       break;
     }
   }
   *aDestLength = iDestLength;
   *aSrcLength = iSrcLength;
   return res;
 }
-
-//----------------------------------------------------------------------
-// Subclassing of nsTableEncoderSupport class [implementation]
-
-NS_IMETHODIMP nsUnicodeToGB2312V2::FillInfo(PRUint32 *aInfo)
-{
-  mUtil.FillGB2312Info(aInfo);
-  //GB2312 font lib also have single byte ASCII characters, set them here
-  for ( PRUint16 u = 0x0000; u <= 0x007F; u++)
-    SET_REPRESENTABLE(aInfo, u);
-  return NS_OK;
-}

--- a/intl/uconv/ucvcn/nsUnicodeToGB2312V2.h
+++ b/intl/uconv/ucvcn/nsUnicodeToGB2312V2.h
@@ -70,14 +70,13 @@ protected:
   // Subclassing of nsEncoderSupport class [declaration]
 
   NS_IMETHOD ConvertNoBuffNoErr(const PRUnichar * aSrc, PRInt32 * aSrcLength, 
                                 char * aDest, PRInt32 * aDestLength)
   {
     return NS_OK;
   }   // just make it not abstract;
 
-  NS_IMETHOD FillInfo(PRUint32 *aInfo);
 protected:
   nsGBKConvUtil mUtil;
 };
 
 #endif /* nsUnicodeToGB2312V2_h___ */

--- a/intl/uconv/ucvcn/nsUnicodeToGBK.cpp
+++ b/intl/uconv/ucvcn/nsUnicodeToGBK.cpp
@@ -41,17 +41,16 @@
  * @created         08/Sept/1999
  * @author  Yueheng Xu, Yueheng.Xu@intel.com
  * Revision History
  * 04/Oct/1999. Yueheng Xu: used table gUnicodeToGBKTable[0x5200] to make 
  *              Unicode to GB mapping fast 
  */
 
 #include "nsUnicodeToGBK.h"
-#include "nsICharRepresentable.h"
 #include "nsUCvCnDll.h"
 #include "gbku.h"
 #include "uconvutil.h"
 #include "nsUnicharUtils.h"
 
 //-------------------------------------------------------------
 // Global table initialization function defined in gbku.h
 //-------------------------------------------------------------
@@ -338,37 +337,8 @@ NS_IMETHODIMP nsUnicodeToGBK::ConvertNoB
       break;
     }
   }
 //afterwhileloop:
   *aDestLength = iDestLength;
   *aSrcLength = iSrcLength;
   return res;
 }
-
-//----------------------------------------------------------------------
-// Subclassing of nsTableEncoderSupport class [implementation]
-
-NS_IMETHODIMP nsUnicodeToGBK::FillInfo(PRUint32 *aInfo)
-{
-  mUtil.FillInfo(aInfo, 0x81, 0xFE, 0x40, 0xFE);
-  if(! mExtensionEncoder )
-    CreateExtensionEncoder();
-  if(mExtensionEncoder) 
-  {
-    nsCOMPtr<nsICharRepresentable> aRep = do_QueryInterface(mExtensionEncoder);
-    aRep->FillInfo(aInfo);
-  }
-  
-  if(! m4BytesEncoder )
-    Create4BytesEncoder();
-  if(m4BytesEncoder) 
-  {
-    nsCOMPtr<nsICharRepresentable> aRep = do_QueryInterface(m4BytesEncoder);
-    aRep->FillInfo(aInfo);
-  }
-
-  //GBK font lib also have single byte ASCII characters, set them here
-  for (PRUint16 SrcUnicode = 0x0000; SrcUnicode <= 0x007F; SrcUnicode++)
-    SET_REPRESENTABLE(aInfo, SrcUnicode);
-  SET_REPRESENTABLE(aInfo, 0x20ac); // euro
-  return NS_OK;
-}

--- a/intl/uconv/ucvcn/nsUnicodeToGBK.h
+++ b/intl/uconv/ucvcn/nsUnicodeToGBK.h
@@ -73,18 +73,16 @@ protected:
                             PRInt32 * aDestLength);
 
   NS_IMETHOD ConvertNoBuffNoErr(const PRUnichar * aSrc, PRInt32 * aSrcLength, 
                                 char * aDest, PRInt32 * aDestLength)
   {
     return NS_OK;
   }  // just make it not abstract;
 
-  NS_IMETHOD FillInfo(PRUint32 *aInfo);
-
   virtual void CreateExtensionEncoder();
   virtual void Create4BytesEncoder();
 
   nsCOMPtr<nsIUnicodeEncoder> mExtensionEncoder;
   nsCOMPtr<nsIUnicodeEncoder> m4BytesEncoder;
 protected:
   PRUnichar mSurrogateHigh;
   nsGBKConvUtil mUtil;

--- a/intl/uconv/ucvcn/nsUnicodeToHZ.cpp
+++ b/intl/uconv/ucvcn/nsUnicodeToHZ.cpp
@@ -143,17 +143,8 @@ NS_IMETHODIMP nsUnicodeToHZ::FinishNoBuf
     aDest[0] = '~';
     aDest[1] = '}';
     *aDestLength = 2;
   } else {
     *aDestLength = 0;
   }
   return NS_OK;
 }
-
-NS_IMETHODIMP nsUnicodeToHZ::FillInfo(PRUint32 *aInfo)
-{
-  mUtil.FillGB2312Info(aInfo);
-  //GB2312 font lib also have single byte ASCII characters, set them here
-  for ( PRUint16 u = 0x0000; u <= 0x007F; u++)
-    SET_REPRESENTABLE(aInfo, u);
-  return NS_OK;
-}

--- a/intl/uconv/ucvcn/nsUnicodeToHZ.h
+++ b/intl/uconv/ucvcn/nsUnicodeToHZ.h
@@ -66,18 +66,16 @@ protected:
   // Subclassing of nsEncoderSupport class [declaration]
   NS_IMETHOD ConvertNoBuff(const PRUnichar * aSrc, 
                             PRInt32 * aSrcLength, 
                             char * aDest, 
                             PRInt32 * aDestLength);
 
   NS_IMETHOD FinishNoBuff(char * aDest, PRInt32 * aDestLength);
 
-  NS_IMETHOD FillInfo(PRUint32 *aInfo);
-
   NS_IMETHOD ConvertNoBuffNoErr(const PRUnichar * aSrc, PRInt32 * aSrcLength, 
                                 char * aDest, PRInt32 * aDestLength)
   {
     return NS_OK;
   }  // just make it not abstract;
 
   PRUint16 mHZState;
 protected:

--- a/intl/uconv/ucvja/nsUnicodeToISO2022JP.cpp
+++ b/intl/uconv/ucvja/nsUnicodeToISO2022JP.cpp
@@ -223,22 +223,16 @@ nsresult nsUnicodeToISO2022JP::ConvertHa
   *aDestLength = dest - aDest;
   *aSrcLength = src - aSrc;
   return res;
 }
 
 //----------------------------------------------------------------------
 // Subclassing of nsTableEncoderSupport class [implementation]
 
-NS_IMETHODIMP nsUnicodeToISO2022JP::FillInfo(PRUint32* aInfo)
-{
-  return nsUnicodeEncodeHelper::FillInfo(aInfo, SIZE_OF_TABLES, 
-                                         (uMappingTable **) g_ufMappingTables);
-
-}
 NS_IMETHODIMP nsUnicodeToISO2022JP::ConvertNoBuffNoErr(
                                     const PRUnichar * aSrc, 
                                     PRInt32 * aSrcLength, 
                                     char * aDest, 
                                     PRInt32 * aDestLength)
 {
   nsresult res = NS_OK;
 

--- a/intl/uconv/ucvja/nsUnicodeToISO2022JP.h
+++ b/intl/uconv/ucvja/nsUnicodeToISO2022JP.h
@@ -74,12 +74,11 @@ protected:
 
   //--------------------------------------------------------------------
   // Subclassing of nsEncoderSupport class [declaration]
 
   NS_IMETHOD ConvertNoBuffNoErr(const PRUnichar * aSrc, PRInt32 * aSrcLength, 
       char * aDest, PRInt32 * aDestLength);
   NS_IMETHOD FinishNoBuff(char * aDest, PRInt32 * aDestLength);
   NS_IMETHOD Reset();
-  NS_IMETHOD FillInfo(PRUint32 *aInfo);
 };
 
 #endif /* nsUnicodeToISO2022JP_h___ */

--- a/intl/uconv/ucvko/nsUnicodeToJamoTTF.cpp
+++ b/intl/uconv/ucvko/nsUnicodeToJamoTTF.cpp
@@ -53,17 +53,16 @@
 #include "nsXPIDLString.h"
 #include "prtypes.h"
 #include "nscore.h"
 #include "nsISupportsUtils.h"
 #include "nsCOMPtr.h"
 #include "nsIUnicodeDecoder.h"
 #include "nsServiceManagerUtils.h"
 #include "nsICharsetConverterManager.h"
-#include "nsICharRepresentable.h"
 #include <string.h>
 
 typedef struct { 
   PRUint8 seq[3];
   PRUint8 liga;
 } JamoNormMap; 
 
 // cluster maps 
@@ -128,43 +127,35 @@ typedef struct {
 #define IS_VO_EXT(wc) ( ((wc) & 0xFF00) == VO_TMPPOS )
 #define IS_TC_EXT(wc) ( ((wc) & 0xFF00) == TC_TMPPOS )
 
 // Glyph code point bases for L,V, and T in  UnBatang-like fonts
 #define UP_LBASE 0xE000  // 0xE000 = Lfill, 0xE006 = Kiyeok 
 #define UP_VBASE 0xE300  // 0xE300 = Vfill, 0xE302 = Ah  
 #define UP_TBASE 0xE404  // 0xE400 = Tfill, 0xE404 = Kiyeok
 
-// EUC-KR decoder for FillInfo.
-static nsCOMPtr<nsIUnicodeDecoder> gDecoder = 0;
-  
-static inline void FillInfoRange     (PRUint32* aInfo, PRUint32 aStart, 
-                                      PRUint32 aEnd);
 static nsresult     JamoNormalize    (const PRUnichar* aInSeq, 
                                       PRUnichar** aOutSeq, PRInt32* aLength);
 static void         JamosToExtJamos  (PRUnichar* aInSeq,  PRInt32* aLength);
 static const JamoNormMap* JamoClusterSearch(JamoNormMap aKey, 
                                             const JamoNormMap* aClusters,
                                             PRInt16 aClustersSize);
-static nsresult     FillInfoEUCKR    (PRUint32 *aInfo, PRUint16 aHigh1, 
-                                      PRUint16 aHigh2);
 
 static PRInt32      JamoNormMapComp  (const JamoNormMap& p1, 
                                       const JamoNormMap& p2);
 static PRInt16      JamoSrchReplace  (const JamoNormMap* aCluster, 
                                       PRUint16 aSize, PRUnichar *aIn, 
                                       PRInt32* aLength, PRUint16 aOffset);
-static nsresult     GetDecoder       (nsIUnicodeDecoder** aDecoder);
 static nsresult     ScanDecomposeSyllable (PRUnichar *aIn, PRInt32* aLength, 
                                            const PRInt32 aMaxLen);
 
 //----------------------------------------------------------------------
 // Class nsUnicodeToJamoTTF [implementation]
   
-NS_IMPL_ISUPPORTS2(nsUnicodeToJamoTTF, nsIUnicodeEncoder, nsICharRepresentable)
+NS_IMPL_ISUPPORTS1(nsUnicodeToJamoTTF, nsIUnicodeEncoder)
 
 NS_IMETHODIMP 
 nsUnicodeToJamoTTF::SetOutputErrorBehavior(PRInt32 aBehavior, 
                                            nsIUnicharEncoder *aEncoder, 
                                            PRUnichar aChar)
 {
   if (aBehavior == kOnError_CallBack && aEncoder == nsnull)
     return NS_ERROR_NULL_POINTER;
@@ -333,60 +324,16 @@ nsUnicodeToJamoTTF::GetMaxLength(const P
                                  PRInt32 * aDestLength)
 {
   // a precomposed Hangul syllable can be decomposed into 3 Jamos, each of
   // which takes 2bytes. 
   *aDestLength = aSrcLength *  6;
   return NS_OK;
 }
 
-
-NS_IMETHODIMP 
-nsUnicodeToJamoTTF::FillInfo(PRUint32* aInfo)
-{
-  FillInfoRange(aInfo, SBASE, SEND);
-
-  PRUnichar i;
-
-  // Hangul Conjoining Jamos
-  for(i = 0x1100; i<= 0x1159; i++)
-     SET_REPRESENTABLE(aInfo, i);
-  SET_REPRESENTABLE(aInfo, 0x115f);
-  for(i = 0x1160; i <= 0x11a2; i++)
-     SET_REPRESENTABLE(aInfo, i);
-  for(i = 0x11a8; i <= 0x11f9; i++)
-     SET_REPRESENTABLE(aInfo, i);
-
-  // Hangul Tone marks
-  SET_REPRESENTABLE(aInfo, HTONE1);
-  SET_REPRESENTABLE(aInfo, HTONE2);
-
-  // UnPark  fonts have US-ASCII chars.
-  for(i=0x20; i < 0x7f; i++)
-     SET_REPRESENTABLE(aInfo, i);
-
-  nsresult rv;
-
-  // UnPark fonts have Hanjas and symbols defined in KS X 1001 as well.
-  
-  // XXX: Do we need to exclude Cyrillic, Greek letters and some Latin letters 
-  // included in KS X 1001 as 'symbol characters'? 
-  // KS X 1001 has only a subset of Greek and Cyrillic alphabets and
-  // Latin letters with diacritic marks so that including them may
-  // result in ransom-note like effect if it is listed *before*
-  // any genuine Greek/Russian/Latin fonts in CSS. 
-    
-  // Lead byte range for symbol chars. in EUC-KR : 0xA1 - 0xAF
-  rv = FillInfoEUCKR(aInfo, 0xA1, 0xAF); 
-  NS_ENSURE_SUCCESS(rv, rv);
-
-  // Lead byte range for Hanja in EUC-KR : 0xCA - 0xFD.
-  return FillInfoEUCKR(aInfo, 0xCA, 0xFD); 
-}
-
 /**
  * Copied from mslvt.otp by Jin-Hwan Cho <chofchof@ktug.or.kr>.
  * Extended by Jungshik Shin <jshin@mailaps.org> to support
  * additional Jamo clusters not encoded in U+1100 Jamo block
  * as precomposed Jamo clsuters. 
  * Corrected by Won-Kyu Park <wkpark@chem.skku.ac.kr>.
  * See http://www.ktug.or.kr for its use in Lambda and swindow/SFontTTF.cpp at  
  * http://www.yudit.org for its use in Yudit.
@@ -679,99 +626,16 @@ nsUnicodeToJamoTTF::RenderAsPrecompSylla
     aResult[mByteOff++] = PRUint8(wc & 0xff);
   }
 
   *aSrcLength -= composed;
 
   return composed;
 }
 
-// Fill up Cmap array quickly for a rather large range.
-/* static */
-inline void FillInfoRange(PRUint32* aInfo, PRUint32 aStart, PRUint32 aEnd)
-{
-
-  PRUint32 b = aStart >> 5; 
-  PRUint32 e = aEnd >> 5;
-
-  if (aStart & 0x1f)
-    aInfo[b++] |= ~ (0xFFFFFFFFL >> (32 - ((aStart) & 0x1f)));
-
-  for( ; b < e ; b++)
-    aInfo[b] |= 0xFFFFFFFFL;
-
-  aInfo[e] |= (0xFFFFFFFFL >> (31 - ((aEnd) & 0x1f)));
-}
-
-
-#define ROWLEN 94
-#define IS_GR94(x) (0xA0 < (x) && (x) < 0xFF)
-
-// Given a range [aHigh1, aHigh2] in high bytes of EUC-KR, convert 
-// rows of 94 characters in the range (row by row) to Unicode and set 
-// representability if the result is not 0xFFFD (Unicode replacement char.).
-/* static */
-nsresult FillInfoEUCKR (PRUint32 *aInfo, PRUint16 aHigh1, PRUint16 aHigh2)
-{
-  char row[ROWLEN * 2];
-  PRUnichar dest[ROWLEN];
-  nsresult rv = NS_OK;
-
-  NS_ENSURE_TRUE(aInfo, NS_ERROR_NULL_POINTER);
-  NS_ENSURE_TRUE(IS_GR94(aHigh1) && IS_GR94(aHigh2), NS_ERROR_INVALID_ARG);
-
-  nsCOMPtr<nsIUnicodeDecoder> decoder;
-  rv = GetDecoder(getter_AddRefs(decoder));
-  NS_ENSURE_SUCCESS(rv,rv);
-
-  for (PRUint16 i = aHigh1 ; i <= aHigh2; i++)
-  {
-    PRUint16 j;
-    // handle a row of 94 char. at a time.
-    for (j = 0 ; j < ROWLEN; j++)
-    {
-      row[j * 2] = char(i);
-      row[j * 2 + 1] = char(j + 0xa1);
-    }
-    PRInt32 srcLen = ROWLEN * 2;
-    PRInt32 destLen = ROWLEN;
-    rv = decoder->Convert(row, &srcLen, dest, &destLen);
-    NS_ENSURE_SUCCESS(rv, rv);
-
-    // set representability according to the conversion result.
-    for (j = 0 ; j < ROWLEN; j++)
-      if (dest[j] != 0xFFFD)
-        SET_REPRESENTABLE(aInfo, dest[j]);
-  }
-  return rv;
-}
-
-/* static */
-nsresult GetDecoder(nsIUnicodeDecoder** aDecoder)
-{
-  nsresult rv; 
-
-  if (gDecoder) {
-    *aDecoder = gDecoder.get();
-    NS_ADDREF(*aDecoder);
-    return NS_OK;
-  }
-
-  nsCOMPtr<nsICharsetConverterManager> charsetConverterManager;
-  charsetConverterManager = do_GetService(NS_CHARSETCONVERTERMANAGER_CONTRACTID, &rv);
-  NS_ENSURE_SUCCESS(rv,rv);
-  rv = charsetConverterManager->GetUnicodeDecoderRaw("EUC-KR", getter_AddRefs(gDecoder));
-  NS_ENSURE_SUCCESS(rv,rv);
-
-  *aDecoder = gDecoder.get();
-  NS_ADDREF(*aDecoder);
-  return NS_OK;
-}
-
-
 /* static */
 PRInt32 JamoNormMapComp (const JamoNormMap& p1, const JamoNormMap& p2)
 {
   if (p1.seq[0] != p2.seq[0]) 
     return p1.seq[0] - p2.seq[0];
   if (p1.seq[1] != p2.seq[1]) 
     return p1.seq[1] - p2.seq[1];
   return p1.seq[2] - p2.seq[2];

--- a/intl/uconv/ucvko/nsUnicodeToJamoTTF.h
+++ b/intl/uconv/ucvko/nsUnicodeToJamoTTF.h
@@ -41,17 +41,17 @@
 #ifndef nsUnicodeToJamoTTF_h___
 #define nsUnicodeToJamoTTF_h___
 
 #include "nsUCSupport.h"
 
 //----------------------------------------------------------------------
 // Class nsUnicodeToJamoTTF [declaration]
 
-class nsUnicodeToJamoTTF : public nsIUnicodeEncoder, public nsICharRepresentable
+class nsUnicodeToJamoTTF : public nsIUnicodeEncoder
 {
 
   NS_DECL_ISUPPORTS
 
 public:
 
   /**
    * Class constructor.
@@ -71,18 +71,16 @@ public:
       PRInt32 * aDestLength);
 
   NS_IMETHOD Reset();
 
   NS_IMETHOD SetOutputErrorBehavior(
       PRInt32 aBehavior,
       nsIUnicharEncoder * aEncoder, PRUnichar aChar);
 
-  NS_IMETHOD FillInfo(PRUint32* aInfo);
-
 protected:
   PRUnichar *mJamos;
   PRUnichar mJamosStatic[9];
   PRInt32  mJamoCount;
   PRInt32  mJamosMaxLength;
   PRInt32  mByteOff;
 
   PRInt32 mErrBehavior;

--- a/intl/uconv/ucvlatin/nsUnicodeToTSCII.cpp
+++ b/intl/uconv/ucvlatin/nsUnicodeToTSCII.cpp
@@ -50,19 +50,19 @@
  *  0xA1..0xA5, 0xAA: Tamil combining letters (after the base character)
  *  0xA6..0xA8:       Tamil combining letters (before the base character)
  *  0x91..0x94:       Punctuation
  *  0xA9:             Symbols
  */
 
 //----------------------------------------------------------------------
 // Class nsUnicodeToTSCII [implementation]
+
+NS_IMPL_ISUPPORTS1(nsUnicodeToTSCII, nsIUnicodeEncoder)
   
-NS_IMPL_ISUPPORTS2(nsUnicodeToTSCII, nsIUnicodeEncoder, nsICharRepresentable)
-
 /* 
  * During UCS-4 to TSCII conversion, mState contains 
  * the last byte (or sometimes the last two bytes) to be output.
  * This can be:
  *   0x00                     Nothing pending.
  *   0xB8..0xC9, 0x83..0x86   A consonant.
  *   0xEC, 0x8A               A consonant with VIRAMA sign (final or joining).
  *   0x87, 0xC38A             Two consonants combined through a VIRAMA sign. 
@@ -385,57 +385,16 @@ nsUnicodeToTSCII::GetMaxLength(const PRU
 {
   // Some Tamil letters  can be decomposed into 2 glyphs in TSCII.
   *aDestLength = aSrcLength *  2;
   return NS_OK;
 }
 
 
 NS_IMETHODIMP 
-nsUnicodeToTSCII::FillInfo(PRUint32* aInfo)
-{
-  // Tamil block is so sparse.
-  static const PRUint8 coverage[] = {
-    0xe8, // 11101000  U+0B87 - U+0B80
-    0xc7, // 11000111  U+0B8F - U+0B88
-    0x3d, // 00111101  U+0B97 - U+0B90
-    0xd6, // 11010110  U+0B9F - U+0B98
-    0x18, // 00011000  U+0BA7 - U+0BA0
-    0xc7, // 11000111  U+0BAF - U+0BA8
-    0xbf, // 10111111  U+0BB7 - U+0BB0
-    0xc7, // 11000111  U+0BBF - U+0BB8
-    0xc7, // 11000111  U+0BC7 - U+0BC0
-    0x3d, // 00111101  U+0BCF - U+0BC8
-    0x80, // 10000000  U+0BD7 - U+0BD0
-    0x00, // 00000000  U+0BDF - U+0BD8
-    0x80, // 10000000  U+0BE7 - U+0BE0
-    0xff, // 11111111  U+0BEF - U+0BE8
-    0x07, // 00000111  U+0BF7 - U+0BF0
-  };
-
-  PRUnichar i;
-  for(i = 0; i <  0x78; i++)
-    if (coverage[i / 8] & (1 << (i % 8)))
-      SET_REPRESENTABLE(aInfo, i + UNI_TAMIL_START);
-
-  // TSCII is a superset of US-ASCII.
-  for(i = 0x20; i < 0x7f; i++)
-     SET_REPRESENTABLE(aInfo, i);
-
-  // additional characters in TSCII
-  SET_REPRESENTABLE(aInfo, 0xA9);   // copyright sign
-  SET_REPRESENTABLE(aInfo, UNI_LEFT_SINGLE_QUOTE);
-  SET_REPRESENTABLE(aInfo, UNI_RIGHT_SINGLE_QUOTE);
-  SET_REPRESENTABLE(aInfo, UNI_LEFT_DOUBLE_QUOTE);
-  SET_REPRESENTABLE(aInfo, UNI_RIGHT_DOUBLE_QUOTE);
-
-  return NS_OK;
-}
-
-NS_IMETHODIMP 
 nsUnicodeToTSCII::SetOutputErrorBehavior(PRInt32 aBehavior, 
                                            nsIUnicharEncoder *aEncoder, 
                                            PRUnichar aChar)
 {
   return NS_OK;
 }
 
 

--- a/intl/uconv/ucvlatin/nsUnicodeToTSCII.h
+++ b/intl/uconv/ucvlatin/nsUnicodeToTSCII.h
@@ -39,22 +39,21 @@
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef nsUnicodeToTSCII_h___
 #define nsUnicodeToTSCII_h___
 
 #include "nsCOMPtr.h"
 #include "nsISupports.h"
 #include "nsIUnicodeEncoder.h"
-#include "nsICharRepresentable.h"
 
 //----------------------------------------------------------------------
 // Class nsUnicodeToTSCII [declaration]
 
-class nsUnicodeToTSCII : public nsIUnicodeEncoder, public nsICharRepresentable
+class nsUnicodeToTSCII : public nsIUnicodeEncoder
 {
 
 NS_DECL_ISUPPORTS
 
 public:
   nsUnicodeToTSCII() { mBuffer = 0; }
   virtual ~nsUnicodeToTSCII() {}
 
@@ -67,18 +66,16 @@ public:
                           PRInt32 * aDestLength);
 
   NS_IMETHOD Reset();
 
   NS_IMETHOD SetOutputErrorBehavior(PRInt32 aBehavior,
                                     nsIUnicharEncoder * aEncoder, 
                                     PRUnichar aChar);
 
-  NS_IMETHOD FillInfo(PRUint32* aInfo);
-
 private:
   PRUint32 mBuffer; // buffer for character(s) to be combined with the following
                     // character. Up to 4 single byte characters can be 
                     // stored. 
 };
 
 #define CHAR_BUFFER_SIZE 2048
 

--- a/intl/uconv/ucvlatin/nsUnicodeToUCS2BE.cpp
+++ b/intl/uconv/ucvlatin/nsUnicodeToUCS2BE.cpp
@@ -122,22 +122,16 @@ NS_IMETHODIMP nsUnicodeToUTF16BE::Reset(
 }
 
 NS_IMETHODIMP nsUnicodeToUTF16BE::SetOutputErrorBehavior(PRInt32 aBehavior, 
       nsIUnicharEncoder * aEncoder, PRUnichar aChar)
 {
   return NS_OK;
 }
 
-NS_IMETHODIMP nsUnicodeToUTF16BE::FillInfo(PRUint32 *aInfo)
-{
-  ::memset(aInfo, 0xFF, (0x10000L >> 3));
-  return NS_OK;
-}
-
 NS_IMETHODIMP nsUnicodeToUTF16BE::CopyData(char* aDest, const PRUnichar* aSrc, PRInt32 aLen  )
 {
 #ifdef IS_BIG_ENDIAN
   //UnicodeToUTF16SameEndian
   ::memcpy(aDest, (void*) aSrc, aLen * 2);
 #elif defined(IS_LITTLE_ENDIAN)
   //UnicodeToUTF16DiffEndian
   SwapBytes(aDest, aSrc, aLen);

--- a/intl/uconv/ucvlatin/nsUnicodeToUCS2BE.h
+++ b/intl/uconv/ucvlatin/nsUnicodeToUCS2BE.h
@@ -52,20 +52,16 @@ public:
       char * aDest, PRInt32 * aDestLength);
   NS_IMETHOD GetMaxLength(const PRUnichar * aSrc, PRInt32 aSrcLength, 
       PRInt32 * aDestLength);
   NS_IMETHOD Finish(char * aDest, PRInt32 * aDestLength);
   NS_IMETHOD Reset();
   NS_IMETHOD SetOutputErrorBehavior(PRInt32 aBehavior, 
       nsIUnicharEncoder * aEncoder, PRUnichar aChar);
 
-  //--------------------------------------------------------------------
-  // Interface nsICharRepresentable [declaration]
-  NS_IMETHOD FillInfo(PRUint32 *aInfo);
-
 protected:
   PRUnichar mBOM;
   NS_IMETHOD CopyData(char* aDest, const PRUnichar* aSrc, PRInt32 aLen  );
 };
 
 class nsUnicodeToUTF16LE: public nsUnicodeToUTF16BE
 {
 public:

--- a/intl/uconv/ucvlatin/nsUnicodeToUTF32.cpp
+++ b/intl/uconv/ucvlatin/nsUnicodeToUTF32.cpp
@@ -216,22 +216,16 @@ NS_IMPL_ISUPPORTS1(nsUnicodeToUTF32Base,
 NS_IMETHODIMP nsUnicodeToUTF32Base::GetMaxLength(const PRUnichar * aSrc, 
                                                  PRInt32 aSrcLength, 
                                                  PRInt32 * aDestLength)
 {
   *aDestLength = aSrcLength * 4;
   return NS_OK;
 }
 
-NS_IMETHODIMP nsUnicodeToUTF32Base::FillInfo(PRUint32 *aInfo)
-{
-  memset(aInfo, 0xFF, (0x10000L >> 3));
-  return NS_OK;
-}
-
 
 //----------------------------------------------------------------------
 // Class nsUnicodeToUTF32BE [implementation]
 
 //----------------------------------------------------------------------
 // Subclassing of nsUnicodeToUTF32 class [implementation]
   
 

--- a/intl/uconv/ucvlatin/nsUnicodeToUTF32.h
+++ b/intl/uconv/ucvlatin/nsUnicodeToUTF32.h
@@ -67,17 +67,16 @@ protected:
 
   NS_IMETHOD GetMaxLength(const PRUnichar * aSrc, PRInt32 aSrcLength, 
                           PRInt32 * aDestLength);
 
   //--------------------------------------------------------------------
   // Subclassing of nsIUnicodeEncoder class [declaration]
 
   NS_IMETHOD Reset() {mBOM = 0; mHighSurrogate = 0; return NS_OK;}
-  NS_IMETHOD FillInfo(PRUint32* aInfo);
   NS_IMETHOD SetOutputErrorBehavior(PRInt32 aBehavior, 
                                     nsIUnicharEncoder * aEncoder, 
                                     PRUnichar aChar) 
                                     {return NS_OK;}
 
 protected:
   PRUnichar mBOM;
 };

--- a/intl/uconv/ucvlatin/nsUnicodeToUTF7.cpp
+++ b/intl/uconv/ucvlatin/nsUnicodeToUTF7.cpp
@@ -50,22 +50,16 @@
 nsBasicUTF7Encoder::nsBasicUTF7Encoder(char aLastChar, char aEscChar) 
 : nsEncoderSupport(5)
 {
   mLastChar = aLastChar;
   mEscChar = aEscChar;
   Reset();
 }
 
-NS_IMETHODIMP nsBasicUTF7Encoder::FillInfo(PRUint32 *aInfo)
-{
-  memset(aInfo, 0xFF, (0x10000L >> 3));
-  return NS_OK;
-}
-
 nsresult nsBasicUTF7Encoder::ShiftEncoding(PRInt32 aEncoding,
                                           char * aDest, 
                                           PRInt32 * aDestLength)
 {
   if (aEncoding == mEncoding) {
     *aDestLength = 0;
     return NS_OK;
   } 

--- a/intl/uconv/ucvlatin/nsUnicodeToUTF7.h
+++ b/intl/uconv/ucvlatin/nsUnicodeToUTF7.h
@@ -53,18 +53,16 @@ class nsBasicUTF7Encoder : public nsEnco
 {
 public:
 
   /**
    * Class constructor.
    */
   nsBasicUTF7Encoder(char aLastChar, char aEscChar);
 
-  NS_IMETHOD FillInfo(PRUint32 *aInfo);
-
 protected:
 
   PRInt32                   mEncoding;      // current encoding
   PRUint32                  mEncBits;
   PRInt32                   mEncStep;
   char                      mLastChar;
   char                      mEscChar;
 

--- a/intl/uconv/util/nsUCConstructors.h
+++ b/intl/uconv/util/nsUCConstructors.h
@@ -36,17 +36,16 @@
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef __nsUCConstructors_h
 #define __nsUCConstructors_h
 
 #include "nsIUnicodeEncoder.h"
 #include "nsIUnicodeDecoder.h"
 #include "uconvutil.h"
-#include "nsICharRepresentable.h"
 
 // all the useful constructors
 NS_METHOD
 CreateMultiTableDecoder(PRInt32 aTableCount,
                         const uRange * aRangeArray, 
                         uScanClassID * aScanClassArray,
                         uMappingTable ** aMappingTable,
                         PRUint32 aMaxLengthFactor,

--- a/intl/uconv/util/nsUCSupport.cpp
+++ b/intl/uconv/util/nsUCSupport.cpp
@@ -33,17 +33,16 @@
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * 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 "pratom.h"
 #include "nsIComponentManager.h"
-#include "nsICharRepresentable.h"
 #include "nsUCSupport.h"
 #include "nsUnicodeDecodeHelper.h"
 #include "nsUnicodeEncodeHelper.h"
 
 #define DEFAULT_BUFFER_CAPACITY 16
 
 // XXX review the buffer growth limitation code
 
@@ -108,25 +107,16 @@ nsBufferDecoderSupport::~nsBufferDecoder
 void nsBufferDecoderSupport::FillBuffer(const char ** aSrc, PRInt32 aSrcLength)
 {
   PRInt32 bcr = PR_MIN(mBufferCapacity - mBufferLength, aSrcLength);
   memcpy(mBuffer + mBufferLength, *aSrc, bcr);
   mBufferLength += bcr;
   (*aSrc) += bcr;
 }
 
-void nsBufferDecoderSupport::DoubleBuffer()
-{
-  mBufferCapacity *= 2;
-  char * newBuffer = new char [mBufferCapacity];
-  if (mBufferLength > 0) memcpy(newBuffer, mBuffer, mBufferLength);
-  delete [] mBuffer;
-  mBuffer = newBuffer;
-}
-
 //----------------------------------------------------------------------
 // Subclassing of nsBasicDecoderSupport class [implementation]
 
 NS_IMETHODIMP nsBufferDecoderSupport::Convert(const char * aSrc,
                                               PRInt32 * aSrcLength,
                                               PRUnichar * aDest,
                                               PRInt32 * aDestLength)
 {
@@ -371,23 +361,22 @@ nsBasicEncoder::~nsBasicEncoder()
 }
 
 //----------------------------------------------------------------------
 // Interface nsISupports [implementation]
 
 NS_IMPL_ADDREF(nsBasicEncoder)
 NS_IMPL_RELEASE(nsBasicEncoder)
 #ifdef NS_DEBUG
-NS_IMPL_QUERY_INTERFACE3(nsBasicEncoder,
-                         nsIUnicodeEncoder,
-                         nsICharRepresentable, nsIBasicEncoder)
-#else
 NS_IMPL_QUERY_INTERFACE2(nsBasicEncoder,
                          nsIUnicodeEncoder,
-                         nsICharRepresentable)
+                         nsIBasicEncoder)
+#else
+NS_IMPL_QUERY_INTERFACE1(nsBasicEncoder,
+                         nsIUnicodeEncoder)
 #endif
 //----------------------------------------------------------------------
 // Class nsEncoderSupport [implementation]
 
 nsEncoderSupport::nsEncoderSupport(PRUint32 aMaxLengthFactor) :
   mMaxLengthFactor(aMaxLengthFactor)
 {
   mBufferCapacity = DEFAULT_BUFFER_CAPACITY;
@@ -624,20 +613,16 @@ nsTableEncoderSupport::nsTableEncoderSup
   mShiftOutTable = nsnull;
   mMappingTable = aMappingTable;
 }
 
 nsTableEncoderSupport::~nsTableEncoderSupport()
 {
 }
 
-NS_IMETHODIMP nsTableEncoderSupport::FillInfo(PRUint32 *aInfo)
-{
-  return nsUnicodeEncodeHelper::FillInfo(aInfo, mMappingTable);
-}
 //----------------------------------------------------------------------
 // Subclassing of nsEncoderSupport class [implementation]
 
 NS_IMETHODIMP nsTableEncoderSupport::ConvertNoBuffNoErr(
                                      const PRUnichar * aSrc,
                                      PRInt32 * aSrcLength,
                                      char * aDest,
                                      PRInt32 * aDestLength)
@@ -664,20 +649,16 @@ nsMultiTableEncoderSupport::nsMultiTable
   mShiftOutTable = aShiftOutTable;
   mMappingTable = aMappingTable;
 }
 
 nsMultiTableEncoderSupport::~nsMultiTableEncoderSupport()
 {
 }
 
-NS_IMETHODIMP nsMultiTableEncoderSupport::FillInfo(PRUint32 *aInfo)
-{
-  return nsUnicodeEncodeHelper::FillInfo(aInfo,mTableCount, mMappingTable);
-}
 //----------------------------------------------------------------------
 // Subclassing of nsEncoderSupport class [implementation]
 
 NS_IMETHODIMP nsMultiTableEncoderSupport::ConvertNoBuffNoErr(
                                           const PRUnichar * aSrc,
                                           PRInt32 * aSrcLength,
                                           char * aDest,
                                           PRInt32 * aDestLength)

--- a/intl/uconv/util/nsUCSupport.h
+++ b/intl/uconv/util/nsUCSupport.h
@@ -36,17 +36,16 @@
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef nsUCvJaSupport_h___
 #define nsUCvJaSupport_h___
 
 #include "nsCOMPtr.h"
 #include "nsIUnicodeEncoder.h"
 #include "nsIUnicodeDecoder.h"
-#include "nsICharRepresentable.h"
 #include "uconvutil.h"
 #include "mozilla/Mutex.h"
 
 #define ONE_BYTE_TABLE_SIZE 256
 
 #ifdef NS_DEBUG
 // {7AFC9F0A-CFE1-44ea-A755-E3B86AB1226E}
 #define NS_IBASICDECODER_IID \
@@ -146,17 +145,16 @@ protected:
   
   /**
    * Convert method but *without* the buffer management stuff.
    */
   NS_IMETHOD ConvertNoBuff(const char * aSrc, PRInt32 * aSrcLength, 
       PRUnichar * aDest, PRInt32 * aDestLength) = 0;
 
   void FillBuffer(const char ** aSrc, PRInt32 aSrcLength);
-  void DoubleBuffer();
 
 public:
 
   /**
    * Class constructor.
    */
   nsBufferDecoderSupport(PRUint32 aMaxLengthFactor);
 
@@ -291,17 +289,17 @@ protected:
   NS_IMETHOD GetMaxLength(const char * aSrc, PRInt32 aSrcLength, 
       PRInt32 * aDestLength);
   NS_IMETHOD Reset();
 };
 
 //----------------------------------------------------------------------
 // Class nsBasicEncoder [declaration]
 
-class nsBasicEncoder : public nsIUnicodeEncoder, public nsICharRepresentable
+class nsBasicEncoder : public nsIUnicodeEncoder
 #ifdef NS_DEBUG
                        ,public nsIBasicEncoder
 #endif
 {
   NS_DECL_ISUPPORTS
 
 public:
   /**
@@ -393,20 +391,16 @@ public:
       char * aDest, PRInt32 * aDestLength);
   NS_IMETHOD Finish(char * aDest, PRInt32 * aDestLength);
   NS_IMETHOD Reset();
   NS_IMETHOD SetOutputErrorBehavior(PRInt32 aBehavior, 
       nsIUnicharEncoder * aEncoder, PRUnichar aChar);
   NS_IMETHOD GetMaxLength(const PRUnichar * aSrc, 
                           PRInt32 aSrcLength, 
                           PRInt32 * aDestLength);
-
-  //--------------------------------------------------------------------
-  // Interface nsICharRepresentable [declaration]
-  NS_IMETHOD FillInfo(PRUint32 *aInfo) = 0;
 };
 
 //----------------------------------------------------------------------
 // Class nsTableEncoderSupport [declaration]
 
 /**
  * Support class for a single-table-driven Unicode encoder.
  * 
@@ -428,17 +422,16 @@ public:
   nsTableEncoderSupport(uScanClassID  aScanClass,
                         uMappingTable  * aMappingTable,
                         PRUint32 aMaxLengthFactor);
 
   /**
    * Class destructor.
    */
   virtual ~nsTableEncoderSupport();
-  NS_IMETHOD FillInfo( PRUint32 *aInfo);
 
 protected:
 
   uScanClassID              mScanClass;
   uShiftOutTable            * mShiftOutTable;
   uMappingTable             * mMappingTable;
 
   //--------------------------------------------------------------------
@@ -469,17 +462,16 @@ public:
                              uShiftOutTable ** aShiftOutTable,
                              uMappingTable  ** aMappingTable,
                              PRUint32 aMaxLengthFactor);
 
   /**
    * Class destructor.
    */
   virtual ~nsMultiTableEncoderSupport();
-  NS_IMETHOD FillInfo( PRUint32 *aInfo);
 
 protected:
 
   PRInt32                   mTableCount;
   uScanClassID              * mScanClassArray;
   uShiftOutTable            ** mShiftOutTable;
   uMappingTable             ** mMappingTable;
 

--- a/intl/uconv/util/nsUnicodeEncodeHelper.cpp
+++ b/intl/uconv/util/nsUnicodeEncodeHelper.cpp
@@ -147,21 +147,8 @@ nsresult nsUnicodeEncodeHelper::ConvertB
     dest += bcw;
     destLen -= bcw;
   }
 
   *aSrcLength = src - aSrc;
   *aDestLength  = dest - aDest;
   return res;
 }
-
-nsresult nsUnicodeEncodeHelper::FillInfo(PRUint32 *aInfo, uMappingTable  * aMappingTable)
-{
-   uFillInfo((uTable*) aMappingTable, aInfo);
-   return NS_OK;
-}
-
-nsresult nsUnicodeEncodeHelper::FillInfo(PRUint32 *aInfo, PRInt32 aTableCount, uMappingTable  ** aMappingTable)
-{
-   for (PRInt32 i=0; i<aTableCount; i++) 
-      uFillInfo((uTable*) aMappingTable[i], aInfo);
-   return NS_OK;
-}

--- a/intl/uconv/util/nsUnicodeEncodeHelper.h
+++ b/intl/uconv/util/nsUnicodeEncodeHelper.h
@@ -62,19 +62,13 @@ public:
 
   /**
    * Converts data using a set of lookup tables and optional shift tables.
    */
   static nsresult ConvertByMultiTable(const PRUnichar * aSrc, PRInt32 * aSrcLength,
       char * aDest, PRInt32 * aDestLength, PRInt32 aTableCount, 
       uScanClassID * aScanClassArray, 
       uShiftOutTable ** aShiftOutTable, uMappingTable  ** aMappingTable);
-
-  /**
-   * Create Char Representable Info
-   */
-  static nsresult FillInfo(PRUint32* aInfo, uMappingTable  * aMappingTable);
-  static nsresult FillInfo(PRUint32* aInfo, PRInt32 aTableCount, uMappingTable  ** aMappingTable);
 };
 
 #endif // nsUnicodeEncodeHelper_h__
 
 

--- a/intl/uconv/util/umap.c
+++ b/intl/uconv/util/umap.c
@@ -85,38 +85,22 @@ PRIVATE const HitFormateFunc m_hit[uNumF
 {
     uHitFormate0,
     uHitFormate0,
     uHitFormate2,
 };
 
 #define uHit(format,in,cell)   (* m_hit[(format)])((in),(cell))
 #define uMap(format,in,uT,cell)  (* m_map[(format)])((in),(uT),(cell))
-#define uFillInfoCell(format,uT,cell,info)  (* m_fillinfo[(format)])((uT),(cell),(info))
 #define uGetMapCell(uT, item) ((uMapCell *)(((PRUint16 *)uT) + (uT)->offsetToMapCellArray + (item)*(UMAPCELL_SIZE/sizeof(PRUint16))))
 #define uGetFormat(uT, item) (((((PRUint16 *)uT) + (uT)->offsetToFormatArray)[(item)>> 2 ] >> (((item)% 4 ) << 2)) & 0x0f)
 
 /*=================================================================================
 
 =================================================================================*/
-MODULE_PRIVATE void uFillInfo(const uTable *uT, PRUint32* aInfo)
-{
-  PRUint16 itemOfList = uT->itemOfList;
-  PRUint16 i;
-  for(i=0;i<itemOfList;i++)
-  {
-    const uMapCell* uCell;
-    PRInt8 format = uGetFormat(uT,i);
-    uCell = uGetMapCell(uT,i);
-    uFillInfoCell(format, uT, uCell, aInfo);
-  }
-}
-/*=================================================================================
-
-=================================================================================*/
 MODULE_PRIVATE PRBool uMapCode(const uTable *uT, PRUint16 in, PRUint16* out)
 {
   PRBool done = PR_FALSE;
   PRUint16 itemOfList = uT->itemOfList;
   PRUint16 i;
   *out = NOMAPPING;
   for(i=0;i<itemOfList;i++)
   {

--- a/intl/uconv/util/unicpriv.h
+++ b/intl/uconv/util/unicpriv.h
@@ -40,19 +40,16 @@
 #include "ubase.h"
 #include "umap.h"
 #include "uconvutil.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-void	uFillInfo(const uTable *uT, 
-                    PRUint32 *info);
-
 PRBool	uMapCode(const uTable *uT, 
                     PRUint16 in, 
                     PRUint16* out);
 
 PRBool 	uGenerate(uScanClassID scanClass,
                   PRInt32* state, 
                   PRUint16 in, 
                   unsigned char* out, 

--- a/intl/unicharutil/public/nsICaseConversion.h
+++ b/intl/unicharutil/public/nsICaseConversion.h
@@ -62,20 +62,16 @@ public:
   NS_IMETHOD ToTitle( PRUnichar aChar, PRUnichar* aReturn) = 0;
 
   // Convert an array of Unicode characters into upper case
   NS_IMETHOD ToUpper( const PRUnichar* anArray, PRUnichar* aReturn, PRUint32 aLen) = 0;
 
   // Convert an array of Unicode characters into lower case
   NS_IMETHOD ToLower( const PRUnichar* anArray, PRUnichar* aReturn, PRUint32 aLen) = 0;
 
-  // Convert an array of Unicode characters into title case
-  NS_IMETHOD ToTitle( const PRUnichar* anArray, PRUnichar* aReturn, 
-                      PRUint32 aLen, PRBool aStartInWordBundary=PR_TRUE) = 0;
-
   // case-insensitive PRUnichar* comparison - aResult returns similar
   // to strcasecmp
   NS_IMETHOD CaseInsensitiveCompare(const PRUnichar* aLeft, const PRUnichar* aRight, PRUint32 aLength, PRInt32* aResult) = 0;
 };
 
 NS_DEFINE_STATIC_IID_ACCESSOR(nsICaseConversion, NS_ICASECONVERSION_IID)
 
 #endif  /* nsICaseConversion_h__ */

--- a/intl/unicharutil/src/nsCaseConversionImp2.cpp
+++ b/intl/unicharutil/src/nsCaseConversionImp2.cpp
@@ -305,58 +305,16 @@ nsresult nsCaseConversionImp2::ToLower(
 {
   PRUint32 i;
   for(i=0;i<aLen;i++) 
     aReturn[i] = FastToLower(anArray[i]);
   return NS_OK;
 }
 
 
-
-nsresult nsCaseConversionImp2::ToTitle(
-  const PRUnichar* anArray, PRUnichar* aReturn, PRUint32 aLen,
-  PRBool aStartInWordBoundary
-)
-{
-  if(0 == aLen)
-    return NS_OK;
-
-  //
-  // We need to replace this implementation to a real one
-  // Currently, it only do the right thing for ASCII
-  // Howerver, we need a word breaker to do the right job
-  //
-  // this->ToLower(anArray, aReturn, aLen); 
-  // CSS define Capitalize as 
-  //  Uppercases the first character of each word
-  // 
-  
-  PRBool bLastIsSpace =  IS_ASCII_SPACE(anArray[0]);
-  if(aStartInWordBoundary)
-  {
-     this->ToTitle(anArray[0], &aReturn[0]);
-  }
-
-  PRUint32 i;
-  for(i=1;i<aLen;i++)
-  {
-    if(bLastIsSpace)
-    {
-      this->ToTitle(anArray[i], &aReturn[i]);
-    }
-    else
-    {
-      aReturn[i] = anArray[i];
-    }
-
-    bLastIsSpace = IS_ASCII_SPACE(aReturn[i]);
-  }
-  return NS_OK;
-}
-
 // implementation moved from the old nsCRT routine
 NS_IMETHODIMP
 nsCaseConversionImp2::CaseInsensitiveCompare(const PRUnichar *aLeft,
                                              const PRUnichar *aRight,
                                              PRUint32 aCount, PRInt32* aResult)
 {
   if (!aLeft || !aRight)
     return NS_ERROR_INVALID_POINTER;

--- a/intl/unicharutil/src/nsCaseConversionImp2.h
+++ b/intl/unicharutil/src/nsCaseConversionImp2.h
@@ -56,17 +56,14 @@ public:
   NS_IMETHOD ToLower(PRUnichar aChar, PRUnichar* aReturn);
 
   NS_IMETHOD ToTitle(PRUnichar aChar, PRUnichar* aReturn);
 
   NS_IMETHOD ToUpper(const PRUnichar* anArray, PRUnichar* aReturn, PRUint32 aLen);
 
   NS_IMETHOD ToLower(const PRUnichar* anArray, PRUnichar* aReturn, PRUint32 aLen);
 
-  NS_IMETHOD ToTitle(const PRUnichar* anArray, PRUnichar* aReturn, 
-                     PRUint32 aLen, PRBool aStartInWordBoundary = PR_TRUE);
-   
   NS_IMETHOD CaseInsensitiveCompare(const PRUnichar* aLeft, const PRUnichar* aRight, PRUint32 aLength, PRInt32 *aResult);
 };
 
 extern nsCaseConversionImp2* gCaseConv;
 
 #endif

--- a/intl/unicharutil/src/nsEntityConverter.cpp
+++ b/intl/unicharutil/src/nsEntityConverter.cpp
@@ -272,20 +272,8 @@ nsEntityConverter::ConvertToEntities(con
   }
 
   *_retval = ToNewUnicode(outString);
   if (NULL == *_retval) 
     return NS_ERROR_OUT_OF_MEMORY;
 
   return NS_OK;
 }
-
-
-
-nsresult NS_NewEntityConverter(nsISupports** oResult)
-{
-   if(!oResult)
-      return NS_ERROR_NULL_POINTER;
-   *oResult = new nsEntityConverter();
-   if(*oResult)
-      NS_ADDREF(*oResult);
-   return (*oResult) ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
-}

--- a/intl/unicharutil/src/nsEntityConverter.h
+++ b/intl/unicharutil/src/nsEntityConverter.h
@@ -35,18 +35,16 @@
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsIEntityConverter.h"
 #include "nsIFactory.h"
 #include "nsIStringBundle.h"
 #include "nsCOMPtr.h"
 
-nsresult NS_NewEntityConverter(nsISupports** oResult);
-
 #define kVERSION_STRING_LEN 128
 
 class nsEntityVersionList
 {
 public:
     nsEntityVersionList() : mEntities(NULL) {}
     
     PRUint32 mVersion;

--- a/intl/unicharutil/src/nsSaveAsCharset.cpp
+++ b/intl/unicharutil/src/nsSaveAsCharset.cpp
@@ -391,21 +391,8 @@ nsresult nsSaveAsCharset::SetupCharsetLi
 const char * nsSaveAsCharset::GetNextCharset()
 {
   if ((mCharsetListIndex + 1) >= PRInt32(mCharsetList.Length()))
     return nsnull;
 
   // bump the index and return the next charset
   return mCharsetList[++mCharsetListIndex].get();
 }
-
-/////////////////////////////////////////////////////////////////////////////////////////
-
-nsresult 
-NS_NewSaveAsCharset(nsISupports **inst)
-{
-  if(nsnull == inst )
-    return NS_ERROR_NULL_POINTER;
-  *inst = (nsISupports *) new nsSaveAsCharset;
-   if(*inst)
-      NS_ADDREF(*inst);
-   return (*inst) ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
-}

--- a/intl/unicharutil/src/nsSaveAsCharset.h
+++ b/intl/unicharutil/src/nsSaveAsCharset.h
@@ -95,11 +95,8 @@ protected:
   PRUint32 mAttribute;                    // conversion attribute
   PRUint32 mEntityVersion;                // see nsIEntityConverter
   nsCOMPtr<nsIUnicodeEncoder> mEncoder;   // encoder (convert from unicode)
   nsCOMPtr<nsIEntityConverter> mEntityConverter;
   nsTArray<nsCString> mCharsetList;
   PRInt32        mCharsetListIndex;
 };
 
-
-nsresult NS_NewSaveAsCharset(nsISupports **inst);
-

--- a/intl/unicharutil/tests/UnicharSelfTest.cpp
+++ b/intl/unicharutil/tests/UnicharSelfTest.cpp
@@ -371,39 +371,16 @@ void TestCaseConversion()
           if(buf[i] != t3result[i])
           {
             printf("\tFailed!! result unexpected %d\n", i);
             break;
           }
        }
     }
 
-    /* 
-     * It would be pointless to test ToTitle() with the whole buffer, since
-     *  the expected result would be that only the first character would be
-     *  transformed. Instead, pass a series of 2-character buffers starting
-     *  with each character of the test cases, and check that the first
-     *  character is transformed as expected and the second remains unchanged
-     */
-     printf("Test 7 - ToTitle(PRUnichar*, PRUnichar*, PRUint32):\n");
-     for (i = 0; i < T4LEN; i++)
-     {
-       PRUnichar* titleTest = t4data + i;
-       res = t->ToTitle(titleTest, buf, 2);
-       if(NS_FAILED(res)) {
-         printf("\tFailed!! return value != NS_OK\n");
-       } else {
-         if (buf[0] != t4result[i] || buf[1] != t4data[i + 1])
-         {
-           printf("\tFailed!! result unexpected %d\n", i);
-           break;
-         }
-       }
-     }
-
    NS_RELEASE(t);
    }
    printf("==============================\n");
    printf("Finish nsICaseConversion Test \n");
    printf("==============================\n");
 
 }