--- a/chrome/src/nsChromeRegistry.h
+++ b/chrome/src/nsChromeRegistry.h
@@ -57,16 +57,17 @@
 #include "nsTHashtable.h"
 #include "nsURIHashKey.h"
 #include "nsInterfaceHashtable.h"
 #include "nsXULAppAPI.h"
 #include "nsIResProtocolHandler.h"
 #include "nsIXPConnect.h"
 
 #include "mozilla/Omnijar.h"
+#include "mozilla/FileLocation.h"
 
 class nsIDOMWindow;
 class nsIURL;
 
 // The chrome registry is actually split between nsChromeRegistryChrome and
 // nsChromeRegistryContent. The work/data that is common to both resides in
 // the shared nsChromeRegistry implementation, with operations that only make
 // sense for one side erroring out in the other.
@@ -134,39 +135,31 @@ protected:
   static nsresult GetProviderAndPath(nsIURL* aChromeURL,
                                      nsACString& aProvider, nsACString& aPath);
 
 public:
   static already_AddRefed<nsChromeRegistry> GetSingleton();
 
   struct ManifestProcessingContext
   {
-    ManifestProcessingContext(NSLocationType aType, nsILocalFile* aFile)
+    ManifestProcessingContext(NSLocationType aType, mozilla::FileLocation &aFile)
       : mType(aType)
       , mFile(aFile)
-      , mPath(NULL)
-    { }
-
-    ManifestProcessingContext(NSLocationType aType, nsILocalFile* aFile, const char* aPath)
-      : mType(aType)
-      , mFile(aFile)
-      , mPath(aPath)
     { }
 
     ~ManifestProcessingContext()
     { }
 
     nsIURI* GetManifestURI();
     nsIXPConnect* GetXPConnect();
 
     already_AddRefed<nsIURI> ResolveURI(const char* uri);
 
     NSLocationType mType;
-    nsILocalFile* mFile;
-    const char* mPath;
+    mozilla::FileLocation mFile;
     nsCOMPtr<nsIURI> mManifestURI;
     nsCOMPtr<nsIXPConnect> mXPConnect;
   };
 
   virtual void ManifestContent(ManifestProcessingContext& cx, int lineno,
                                char *const * argv, bool platform,
                                bool contentaccessible) = 0;
   virtual void ManifestLocale(ManifestProcessingContext& cx, int lineno,

--- a/chrome/src/nsChromeRegistryChrome.cpp
+++ b/chrome/src/nsChromeRegistryChrome.cpp
@@ -783,37 +783,19 @@ nsChromeRegistryChrome::GetXULOverlays(n
   return NS_NewArrayEnumerator(aResult, *parray);
 }
 #endif // MOZ_XUL
 
 nsIURI*
 nsChromeRegistry::ManifestProcessingContext::GetManifestURI()
 {
   if (!mManifestURI) {
-    nsCOMPtr<nsIIOService> io = mozilla::services::GetIOService();
-    if (!io) {
-      NS_WARNING("No IO service trying to process chrome manifests");
-      return NULL;
-    }
-
-    if (mPath) {
-      nsCOMPtr<nsIURI> fileURI;
-      io->NewFileURI(mFile, getter_AddRefs(fileURI));
-
-      nsCAutoString spec;
-      fileURI->GetSpec(spec);
-      spec.Insert(NS_LITERAL_CSTRING("jar:"), 0);
-      spec.AppendLiteral("!/");
-      spec.Append(mPath);
-
-      NS_NewURI(getter_AddRefs(mManifestURI), spec, NULL, NULL, io);
-    }
-    else {
-      io->NewFileURI(mFile, getter_AddRefs(mManifestURI));
-    }
+    nsCString uri;
+    mFile.GetURIString(uri);
+    NS_NewURI(getter_AddRefs(mManifestURI), uri);
   }
   return mManifestURI;
 }
 
 nsIXPConnect*
 nsChromeRegistry::ManifestProcessingContext::GetXPConnect()
 {
   if (!mXPConnect)

--- a/js/xpconnect/loader/mozJSComponentLoader.cpp
+++ b/js/xpconnect/loader/mozJSComponentLoader.cpp
@@ -93,16 +93,17 @@
 #include "mozilla/scache/StartupCache.h"
 #include "mozilla/scache/StartupCacheUtils.h"
 #include "mozilla/Omnijar.h"
 
 #include "jsdbgapi.h"
 
 #include "mozilla/FunctionTimer.h"
 
+using namespace mozilla;
 using namespace mozilla::scache;
 
 static const char kJSRuntimeServiceContractID[] = "@mozilla.org/js/xpc/RuntimeService;1";
 static const char kXPConnectServiceContractID[] = "@mozilla.org/js/xpc/XPConnect;1";
 static const char kObserverServiceContractID[] = "@mozilla.org/observer-service;1";
 static const char kJSCachePrefix[] = "jsloader";
 
 /* Some platforms don't have an implementation of PR_MemMap(). */
@@ -481,83 +482,48 @@ mozJSComponentLoader::ReallyInit()
     fprintf(stderr, "mJCL: ReallyInit success!\n");
 #endif
     mInitialized = true;
 
     return NS_OK;
 }
 
 const mozilla::Module*
-mozJSComponentLoader::LoadModule(nsILocalFile* aComponentFile)
+mozJSComponentLoader::LoadModule(FileLocation &aFile)
 {
+    nsCOMPtr<nsILocalFile> file = aFile.GetBaseFile();
+
+    nsCString spec;
+    aFile.GetURIString(spec);
+
     nsCOMPtr<nsIURI> uri;
-    nsCAutoString spec;
-    NS_GetURLSpecFromActualFile(aComponentFile, spec);
-
     nsresult rv = NS_NewURI(getter_AddRefs(uri), spec);
     if (NS_FAILED(rv))
         return NULL;
 
-    return LoadModuleImpl(aComponentFile,
-                          spec,
-                          uri);
-}
-
-const mozilla::Module*
-mozJSComponentLoader::LoadModuleFromJAR(nsILocalFile *aJarFile,
-                                        const nsACString &aComponentPath)
-{
-    nsresult rv;
-
-    nsCAutoString fullSpec, fileSpec;
-    NS_GetURLSpecFromActualFile(aJarFile, fileSpec);
-    fullSpec = "jar:";
-    fullSpec += fileSpec;
-    fullSpec += "!/";
-    fullSpec += aComponentPath;
-
-    nsCOMPtr<nsIURI> uri;
-    rv = NS_NewURI(getter_AddRefs(uri), fullSpec);
-    if (NS_FAILED(rv))
-        return NULL;
-
-    return LoadModuleImpl(aJarFile,
-                          fullSpec,
-                          uri);
-}
-
-const mozilla::Module*
-mozJSComponentLoader::LoadModuleImpl(nsILocalFile* aSourceFile,
-                                     nsACString &aKey,
-                                     nsIURI* aComponentURI)
-{
-    nsresult rv;
-
 #ifdef NS_FUNCTION_TIMER
-    nsCAutoString spec__("N/A");
-    aComponentURI->GetSpec(spec__);
     NS_TIME_FUNCTION_FMT("%s (line %d) (file: %s)", MOZ_FUNCTION_NAME,
-                         __LINE__, spec__.get());
+                         __LINE__, spec.get());
 #endif
 
     if (!mInitialized) {
         rv = ReallyInit();
         if (NS_FAILED(rv))
             return NULL;
     }
 
     ModuleEntry* mod;
-    if (mModules.Get(aKey, &mod))
+    if (mModules.Get(spec, &mod))
 	return mod;
 
     nsAutoPtr<ModuleEntry> entry(new ModuleEntry);
     if (!entry)
         return NULL;
 
-    rv = GlobalForLocation(aSourceFile, aComponentURI, &entry->global,
+    rv = GlobalForLocation(file, uri, &entry->global,
                            &entry->location, nsnull);
     if (NS_FAILED(rv)) {
 #ifdef DEBUG_shaver
         fprintf(stderr, "GlobalForLocation failed!\n");
 #endif
         return NULL;
     }
 
@@ -595,17 +561,17 @@ mozJSComponentLoader::LoadModuleImpl(nsI
 #ifdef DEBUG_shaver
         fprintf(stderr, "GetJSObject of ComponentManager failed\n");
 #endif
         return NULL;
     }
 
     JSObject* file_jsobj;
     nsCOMPtr<nsIXPConnectJSObjectHolder> file_holder;
-    rv = xpc->WrapNative(cx, entry->global, aSourceFile,
+    rv = xpc->WrapNative(cx, entry->global, file,
                          NS_GET_IID(nsIFile),
                          getter_AddRefs(file_holder));
 
     if (NS_FAILED(rv)) {
         return NULL;
     }
 
     rv = file_holder->GetJSObject(&file_jsobj);
@@ -619,17 +585,17 @@ mozJSComponentLoader::LoadModuleImpl(nsI
 
     if (!JS_GetProperty(cx, entry->global, "NSGetFactory", &NSGetFactory_val) ||
         JSVAL_IS_VOID(NSGetFactory_val)) {
         return NULL;
     }
 
     if (JS_TypeOfValue(cx, NSGetFactory_val) != JSTYPE_FUNCTION) {
         nsCAutoString spec;
-        aComponentURI->GetSpec(spec);
+        uri->GetSpec(spec);
         JS_ReportError(cx, "%s has NSGetFactory property that is not a function",
                        spec.get());
         return NULL;
     }
 
     JSObject *jsGetFactoryObj;
     if (!JS_ValueToObject(cx, NSGetFactory_val, &jsGetFactoryObj) ||
         !jsGetFactoryObj) {
@@ -643,17 +609,17 @@ mozJSComponentLoader::LoadModuleImpl(nsI
         /* XXX report error properly */
 #ifdef DEBUG
         fprintf(stderr, "mJCL: couldn't get nsIModule from jsval\n");
 #endif
         return NULL;
     }
 
     // Cache this module for later
-    if (!mModules.Put(aKey, entry))
+    if (!mModules.Put(spec, entry))
         return NULL;
 
     // The hash owns the ModuleEntry now, forget about it
     return entry.forget();
 }
 
 // Some stack based classes for cleaning up on early return
 #ifdef HAVE_PR_MEMMAP

--- a/js/xpconnect/loader/mozJSComponentLoader.h
+++ b/js/xpconnect/loader/mozJSComponentLoader.h
@@ -74,30 +74,24 @@ class mozJSComponentLoader : public mozi
     NS_DECL_ISUPPORTS
     NS_DECL_XPCIJSMODULELOADER
     NS_DECL_NSIOBSERVER
 
     mozJSComponentLoader();
     virtual ~mozJSComponentLoader();
 
     // ModuleLoader
-    const mozilla::Module* LoadModule(nsILocalFile* aFile);
-    const mozilla::Module* LoadModuleFromJAR(nsILocalFile* aJARFile,
-                                             const nsACString& aPath);
+    const mozilla::Module* LoadModule(mozilla::FileLocation &aFile);
 
  protected:
     static mozJSComponentLoader* sSelf;
 
     nsresult ReallyInit();
     void UnloadModules();
 
-    const mozilla::Module* LoadModuleImpl(nsILocalFile* aSourceFile,
-                                          nsACString &aKey,
-                                          nsIURI* aComponentURI);
-
     nsresult GlobalForLocation(nsILocalFile* aComponentFile,
                                nsIURI *aComponent,
                                JSObject **aGlobal,
                                char **location,
                                jsval *exception);
 
     nsCOMPtr<nsIComponentManager> mCompMgr;
     nsCOMPtr<nsIJSRuntimeService> mRuntimeService;

--- a/xpcom/components/ManifestParser.cpp
+++ b/xpcom/components/ManifestParser.cpp
@@ -169,51 +169,46 @@ void LogMessage(const char* aMsg, ...)
   AutoPR_smprintf_free formatted(PR_vsmprintf(aMsg, args));
   va_end(args);
 
   nsCOMPtr<nsIConsoleMessage> error =
     new nsConsoleMessage(NS_ConvertUTF8toUTF16(formatted).get());
   console->LogMessage(error);
 }
 
-void LogMessageWithContext(nsILocalFile* aFile, const char* aPath,
+void LogMessageWithContext(FileLocation &aFile,
                            PRUint32 aLineNumber, const char* aMsg, ...)
 {
   va_list args;
   va_start(args, aMsg);
   AutoPR_smprintf_free formatted(PR_vsmprintf(aMsg, args));
   va_end(args);
   if (!formatted)
     return;
 
-  nsString file;
-  aFile->GetPath(file);
-  if (aPath) {
-    file.Append(':');
-    file.Append(NS_ConvertUTF8toUTF16(aPath));
-  }
+  nsCString file;
+  aFile.GetURIString(file);
 
   nsCOMPtr<nsIScriptError> error =
     do_CreateInstance(NS_SCRIPTERROR_CONTRACTID);
   if (!error) {
     // This can happen early in component registration. Fall back to a
     // generic console message.
-    LogMessage("Warning: in file '%s', line %i: %s",
-               NS_ConvertUTF16toUTF8(file).get(),
+    LogMessage("Warning: in '%s', line %i: %s", file.get(),
                aLineNumber, (char*) formatted);
     return;
   }
 
   nsCOMPtr<nsIConsoleService> console =
     do_GetService(NS_CONSOLESERVICE_CONTRACTID);
   if (!console)
     return;
 
   nsresult rv = error->Init(NS_ConvertUTF8toUTF16(formatted).get(),
-			    file.get(), NULL,
+			    NS_ConvertUTF8toUTF16(file).get(), NULL,
 			    aLineNumber, 0, nsIScriptError::warningFlag,
 			    "chrome registration");
   if (NS_FAILED(rv))
     return;
 
   console->LogMessage(error);
 }
 
@@ -418,22 +413,22 @@ namespace {
 struct CachedDirective
 {
   int lineno;
   char* argv[4];
 };
 
 } // anonymous namespace
 
-static void
-ParseManifestCommon(NSLocationType aType, nsILocalFile* aFile,
-                    nsComponentManagerImpl::ManifestProcessingContext& mgrcx,
-                    nsChromeRegistry::ManifestProcessingContext& chromecx,
-                    const char* aPath, char* buf, bool aChromeOnly)
+
+void
+ParseManifest(NSLocationType type, FileLocation &file, char* buf, bool aChromeOnly)
 {
+  nsComponentManagerImpl::ManifestProcessingContext mgrcx(type, file, aChromeOnly);
+  nsChromeRegistry::ManifestProcessingContext chromecx(type, file);
   nsresult rv;
 
   NS_NAMED_LITERAL_STRING(kPlatform, "platform");
   NS_NAMED_LITERAL_STRING(kContentAccessible, "contentaccessible");
   NS_NAMED_LITERAL_STRING(kApplication, "application");
   NS_NAMED_LITERAL_STRING(kAppVersion, "appversion");
   NS_NAMED_LITERAL_STRING(kGeckoVersion, "platformversion");
   NS_NAMED_LITERAL_STRING(kOs, "os");
@@ -548,43 +543,43 @@ ParseManifestCommon(NSLocationType aType
 	 ++d) {
       if (!strcmp(d->directive, token)) {
 	directive = d;
 	break;
       }
     }
 
     if (!directive) {
-      LogMessageWithContext(aFile, aPath, line,
+      LogMessageWithContext(file, line,
                             "Ignoring unrecognized chrome manifest directive '%s'.",
                             token);
       continue;
     }
 
-    if (!directive->allowbootstrap && NS_BOOTSTRAPPED_LOCATION == aType) {
-      LogMessageWithContext(aFile, aPath, line,
+    if (!directive->allowbootstrap && NS_BOOTSTRAPPED_LOCATION == type) {
+      LogMessageWithContext(file, line,
                             "Bootstrapped manifest not allowed to use '%s' directive.",
                             token);
       continue;
     }
 
-    if (directive->componentonly && NS_SKIN_LOCATION == aType) {
-      LogMessageWithContext(aFile, aPath, line,
+    if (directive->componentonly && NS_SKIN_LOCATION == type) {
+      LogMessageWithContext(file, line,
                             "Skin manifest not allowed to use '%s' directive.",
                             token);
       continue;
     }
 
     NS_ASSERTION(directive->argc < 4, "Need to reset argv array length");
     char* argv[4];
     for (int i = 0; i < directive->argc; ++i)
       argv[i] = nsCRT::strtok(whitespace, kWhitespace, &whitespace);
 
     if (!argv[directive->argc - 1]) {
-      LogMessageWithContext(aFile, aPath, line,
+      LogMessageWithContext(file, line,
                             "Not enough arguments for chrome manifest directive '%s', expected %i.",
                             token, directive->argc);
       continue;
     }
 
     bool ok = true;
     TriState stAppVersion = eUnspecified;
     TriState stGeckoVersion = eUnspecified;
@@ -609,23 +604,23 @@ ParseManifestCommon(NSLocationType aType
 
       if (directive->contentflags &&
           (CheckFlag(kPlatform, wtoken, platform) ||
            CheckFlag(kContentAccessible, wtoken, contentAccessible)))
         continue;
 
       bool xpcNativeWrappers = true; // Dummy for CheckFlag.
       if (CheckFlag(kXPCNativeWrappers, wtoken, xpcNativeWrappers)) {
-        LogMessageWithContext(aFile, aPath, line,
+        LogMessageWithContext(file, line,
                               "Warning: Ignoring obsolete chrome registration modifier '%s'.",
                               token);
         continue;
       }
 
-      LogMessageWithContext(aFile, aPath, line,
+      LogMessageWithContext(file, line,
                             "Unrecognized chrome manifest modifier '%s'.",
                             token);
       ok = false;
     }
 
     if (!ok ||
         stApp == eBad ||
         stAppVersion == eBad ||
@@ -638,17 +633,17 @@ ParseManifestCommon(NSLocationType aType
     if (directive->regfunc) {
       if (GeckoProcessType_Default != XRE_GetProcessType())
         continue;
 
       if (!nsChromeRegistry::gChromeRegistry) {
         nsCOMPtr<nsIChromeRegistry> cr =
           mozilla::services::GetChromeRegistryService();
         if (!nsChromeRegistry::gChromeRegistry) {
-          LogMessageWithContext(aFile, aPath, line,
+          LogMessageWithContext(file, line,
                                 "Chrome registry isn't available yet.");
           continue;
         }
       }
 
       (nsChromeRegistry::gChromeRegistry->*(directive->regfunc))
 	(chromecx, line, argv, platform, contentAccessible);
     }
@@ -666,27 +661,8 @@ ParseManifestCommon(NSLocationType aType
   }
 
   for (PRUint32 i = 0; i < contracts.Length(); ++i) {
     CachedDirective& d = contracts[i];
     nsComponentManagerImpl::gComponentManager->ManifestContract
       (mgrcx, d.lineno, d.argv);
   }
 }
-
-void
-ParseManifest(NSLocationType type, nsILocalFile* file,
-              char* buf, bool aChromeOnly)
-{
-  nsComponentManagerImpl::ManifestProcessingContext mgrcx(type, file, aChromeOnly);
-  nsChromeRegistry::ManifestProcessingContext chromecx(type, file);
-  ParseManifestCommon(type, file, mgrcx, chromecx, NULL, buf, aChromeOnly);
-}
-
-void
-ParseManifest(NSLocationType type, nsIZipReader* reader, const char* jarPath,
-              char* buf, bool aChromeOnly)
-{
-  nsComponentManagerImpl::ManifestProcessingContext mgrcx(type, reader, jarPath, aChromeOnly);
-  nsChromeRegistry::ManifestProcessingContext chromecx(type, mgrcx.mFile, jarPath);
-  ParseManifestCommon(type, mgrcx.mFile, mgrcx, chromecx, jarPath,
-                      buf, aChromeOnly);
-}

--- a/xpcom/components/ManifestParser.h
+++ b/xpcom/components/ManifestParser.h
@@ -35,24 +35,21 @@
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef ManifestParser_h
 #define ManifestParser_h
 
 #include "nsComponentManager.h"
 #include "nsChromeRegistry.h"
+#include "mozilla/FileLocation.h"
 
 class nsILocalFile;
-class nsIZipReader;
 
-void ParseManifest(NSLocationType type, nsILocalFile* file,
+void ParseManifest(NSLocationType type, mozilla::FileLocation &file,
                    char* buf, bool aChromeOnly);
 
-void ParseManifest(NSLocationType type, nsIZipReader* reader,
-                   const char* jarPath, char* buf, bool aChromeOnly);
-
 void LogMessage(const char* aMsg, ...);
 
-void LogMessageWithContext(nsILocalFile* aFile, const char* aPath,
+void LogMessageWithContext(mozilla::FileLocation &aFile,
                            PRUint32 aLineNumber, const char* aMsg, ...);
 
 #endif // ManifestParser_h

--- a/xpcom/components/ModuleLoader.h
+++ b/xpcom/components/ModuleLoader.h
@@ -36,16 +36,17 @@
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef mozilla_ModuleLoader_h
 #define mozilla_ModuleLoader_h
 
 #include "nsISupports.h"
 #include "mozilla/Module.h"
+#include "mozilla/FileLocation.h"
 
 #define MOZILLA_MODULELOADER_PSEUDO_IID \
 { 0xD951A8CE, 0x6E9F, 0x464F, \
   { 0x8A, 0xC8, 0x14, 0x61, 0xC0, 0xD3, 0x63, 0xC8 } }
 
 namespace mozilla {
 
 /**
@@ -61,21 +62,15 @@ public:
   NS_DECLARE_STATIC_IID_ACCESSOR(MOZILLA_MODULELOADER_PSEUDO_IID)
 
   /**
    * Return the module for a specified file. The caller should cache
    * the module: the implementer should not expect for the same file
    * to be loaded multiple times. The Module object should either be
    * statically or permanently allocated; it will not be freed.
    */
-  virtual const Module* LoadModule(nsILocalFile* aFile) = 0;
-
-  /**
-   * Return the module for a file located within a JAR.
-   */
-  virtual const Module* LoadModuleFromJAR(nsILocalFile* aJARFile,
-                                          const nsACString& aPath) = 0;
+  virtual const Module* LoadModule(mozilla::FileLocation &aFile) = 0;
 };
 NS_DEFINE_STATIC_IID_ACCESSOR(ModuleLoader, MOZILLA_MODULELOADER_PSEUDO_IID)
 
 } // namespace mozilla
 
 #endif // mozilla_ModuleLoader_h

--- a/xpcom/components/nsComponentManager.cpp
+++ b/xpcom/components/nsComponentManager.cpp
@@ -94,23 +94,20 @@
 #include "mozilla/Services.h"
 
 #include "nsManifestLineReader.h"
 #include "mozilla/GenericFactory.h"
 #include "nsSupportsPrimitives.h"
 #include "nsArrayEnumerator.h"
 #include "nsStringEnumerator.h"
 #include "mozilla/FileUtils.h"
-#include "nsURLHelper.h"
 
 #include NEW_H     // for placement new
 
 #include "mozilla/Omnijar.h"
-#include "nsJAR.h"
-static NS_DEFINE_CID(kZipReaderCID, NS_ZIPREADER_CID);
 
 #include "prlog.h"
 
 using namespace mozilla;
 
 PRLogModuleInfo* nsComponentManagerLog = nsnull;
 
 #if 0 || defined (DEBUG_timeless)
@@ -352,27 +349,27 @@ nsresult nsComponentManagerImpl::Init()
         GetLocationFromDirectoryService(NS_GRE_DIR);
     nsCOMPtr<nsILocalFile> appDir =
         GetLocationFromDirectoryService(NS_XPCOM_CURRENT_PROCESS_DIR);
 
     InitializeStaticModules();
     InitializeModuleLocations();
 
     ComponentLocation* cl = sModuleLocations->InsertElementAt(0);
+    nsCOMPtr<nsILocalFile> lf = CloneAndAppend(appDir, NS_LITERAL_CSTRING("chrome.manifest"));
     cl->type = NS_COMPONENT_LOCATION;
-    cl->location = CloneAndAppend(appDir, NS_LITERAL_CSTRING("chrome.manifest"));
-    cl->jar = false;
+    cl->location.Init(lf);
 
     bool equals = false;
     appDir->Equals(greDir, &equals);
     if (!equals) {
         cl = sModuleLocations->InsertElementAt(0);
         cl->type = NS_COMPONENT_LOCATION;
-        cl->location = CloneAndAppend(greDir, NS_LITERAL_CSTRING("chrome.manifest"));
-        cl->jar = false;
+        lf = CloneAndAppend(greDir, NS_LITERAL_CSTRING("chrome.manifest"));
+        cl->location.Init(lf);
     }
 
     PR_LOG(nsComponentManagerLog, PR_LOG_DEBUG,
            ("nsComponentManager: Initialized."));
 
     NS_TIME_FUNCTION_MARK("Next: init native module loader");
     nsresult rv = mNativeModuleLoader.Init();
     if (NS_FAILED(rv))
@@ -380,61 +377,57 @@ nsresult nsComponentManagerImpl::Init()
 
     nsCategoryManager::GetSingleton()->SuppressNotifications(true);
 
     RegisterModule(&kXPCOMModule, NULL);
 
     for (PRUint32 i = 0; i < sStaticModules->Length(); ++i)
         RegisterModule((*sStaticModules)[i], NULL);
 
-    nsCOMPtr<nsIFile> appOmnijar = mozilla::Omnijar::GetPath(mozilla::Omnijar::APP);
+    nsRefPtr<nsZipArchive> appOmnijar = mozilla::Omnijar::GetReader(mozilla::Omnijar::APP);
     if (appOmnijar) {
         cl = sModuleLocations->InsertElementAt(1); // Insert after greDir
         cl->type = NS_COMPONENT_LOCATION;
-        cl->location = do_QueryInterface(appOmnijar);
-        cl->jar = true;
+        cl->location.Init(appOmnijar, "chrome.manifest");
     }
-    nsCOMPtr<nsIFile> greOmnijar = mozilla::Omnijar::GetPath(mozilla::Omnijar::GRE);
+    nsRefPtr<nsZipArchive> greOmnijar = mozilla::Omnijar::GetReader(mozilla::Omnijar::GRE);
     if (greOmnijar) {
         cl = sModuleLocations->InsertElementAt(0);
         cl->type = NS_COMPONENT_LOCATION;
-        cl->location = do_QueryInterface(greOmnijar);
-        cl->jar = true;
+        cl->location.Init(greOmnijar, "chrome.manifest");
     }
 
     RereadChromeManifests(false);
 
     nsCategoryManager::GetSingleton()->SuppressNotifications(false);
 
     mStatus = NORMAL;
 
     return NS_OK;
 }
 
 void
 nsComponentManagerImpl::RegisterModule(const mozilla::Module* aModule,
-                                       nsILocalFile* aFile)
+                                       FileLocation* aFile)
 {
     ReentrantMonitorAutoEnter mon(mMon);
 
-    KnownModule* m = new KnownModule(aModule, aFile);
+    KnownModule* m;
     if (aFile) {
-        nsCAutoString uri;
-        nsresult rv = net_GetURLSpecFromActualFile(aFile, uri);
-        if (NS_FAILED(rv)) {
-            NS_WARNING("net_GetURLSpecFromActualFile failed");
-            return;
-        }
+        nsCString uri;
+        aFile->GetURIString(uri);
         NS_ASSERTION(!mKnownModules.Get(uri),
                      "Must not register a binary module twice.");
 
+        m = new KnownModule(aModule, *aFile);
         mKnownModules.Put(uri, m);
+    } else {
+        m = new KnownModule(aModule);
+        mKnownStaticModules.AppendElement(m);
     }
-    else
-        mKnownStaticModules.AppendElement(m);
 
     if (aModule->mCIDs) {
         const mozilla::Module::CIDEntry* entry;
         for (entry = aModule->mCIDs; entry->cid; ++entry)
             RegisterCIDEntry(entry, m);
     }
 
     if (aModule->mContractIDs) {
@@ -511,334 +504,145 @@ CutExtension(nsCString& path)
 {
     PRInt32 dotPos = path.RFindChar('.');
     if (kNotFound == dotPos)
         path.Truncate();
     else
         path.Cut(0, dotPos + 1);
 }
 
-static nsCString
-GetExtension(nsILocalFile* file)
-{
-    nsCString extension;
-    file->GetNativePath(extension);
-    CutExtension(extension);
-    return extension;
-}
-
-static already_AddRefed<nsIInputStream>
-LoadEntry(nsIZipReader* aReader, const char* aName)
-{
-    if (!aReader)
-        return NULL;
-
-    nsCOMPtr<nsIInputStream> is;
-    nsresult rv = aReader->GetInputStream(nsDependentCString(aName), getter_AddRefs(is));
-    if (NS_FAILED(rv))
-        return NULL;
-
-    return is.forget();
-}
-
 void
-nsComponentManagerImpl::RegisterJarManifest(NSLocationType aType, nsIZipReader* aReader,
-                                            const char* aPath, bool aChromeOnly)
+nsComponentManagerImpl::RegisterManifest(NSLocationType aType,
+                                         FileLocation &aFile,
+                                         bool aChromeOnly)
 {
-    nsCOMPtr<nsIInputStream> is = LoadEntry(aReader, aPath);
-    if (!is) {
-        if (NS_BOOTSTRAPPED_LOCATION != aType)
-            LogMessage("Could not find jar manifest entry '%s'.", aPath);
-        return;
-    }
-
-    PRUint32 flen;
-    is->Available(&flen);
-
-    nsAutoArrayPtr<char> whole(new char[flen + 1]);
-    if (!whole)
-        return;
-
-    for (PRUint32 totalRead = 0; totalRead < flen; ) {
-        PRUint32 avail;
-        PRUint32 read;
-
-        if (NS_FAILED(is->Available(&avail)))
-            return;
-
-        if (avail > flen)
-            return;
-
-        if (NS_FAILED(is->Read(whole + totalRead, avail, &read)))
-            return;
-
-        totalRead += read;
+    PRUint32 len;
+    FileLocation::Data data;
+    nsAutoArrayPtr<char> buf;
+    nsresult rv = aFile.GetData(data);
+    if (NS_SUCCEEDED(rv)) {
+        rv = data.GetSize(&len);
     }
-
-    whole[flen] = '\0';
-
-    ParseManifest(aType, aReader, aPath,
-                  whole, aChromeOnly);
-}
-
-void
-nsComponentManagerImpl::RegisterManifestFile(NSLocationType aType,
-                                             nsILocalFile* aFile,
-                                             bool aChromeOnly)
-{
-    nsresult rv;
-
-    mozilla::AutoFDClose fd;
-    rv = aFile->OpenNSPRFileDesc(PR_RDONLY, 0444, &fd);
-    if (NS_FAILED(rv)) {
-        nsCAutoString path;
-        aFile->GetNativePath(path);
-        if (NS_BOOTSTRAPPED_LOCATION != aType)
-            LogMessage("Could not read chrome manifest file '%s'.", path.get());
-        return;
+    if (NS_SUCCEEDED(rv)) {
+        buf = new char[len + 1];
+        rv = data.Copy(buf, len);
     }
-
-    PRFileInfo64 fileInfo;
-    if (PR_SUCCESS != PR_GetOpenFileInfo64(fd, &fileInfo))
-        return;
-
-    if (fileInfo.size > PRInt64(PR_INT32_MAX))
-        return;
-
-    nsAutoArrayPtr<char> data(new char[PRInt32(fileInfo.size + 1)]);
-
-    for (PRInt32 totalRead = 0; totalRead < fileInfo.size; ) {
-        PRInt32 read = PR_Read(fd, data + totalRead, PRInt32(fileInfo.size));
-        if (read < 0)
-            return;
-        totalRead += read;
+    if (NS_SUCCEEDED(rv)) {
+        buf[len] = '\0';
+        ParseManifest(aType, aFile, buf, aChromeOnly);
+    } else if (NS_BOOTSTRAPPED_LOCATION != aType) {
+        nsCString uri;
+        aFile.GetURIString(uri);
+        LogMessage("Could not read chrome manifest '%s'.", uri.get());
     }
-
-    data[fileInfo.size] = '\0';
-    ParseManifest(aType, aFile, data, aChromeOnly);
-}
-
-#if defined(XP_WIN) || defined(XP_OS2)
-#define TRANSLATE_SLASHES
-static void
-TranslateSlashes(char* path)
-{
-    for (; *path; ++path) {
-        if ('/' == *path)
-            *path = '\\';
-    }
-}
-#endif
-
-static void
-AppendFileToManifestPath(nsCString& path,
-                         const char* file)
-{
-    PRInt32 i = path.RFindChar('/');
-    if (kNotFound == i)
-        path.Truncate(0);
-    else
-        path.Truncate(i + 1);
-
-    path.Append(file);
 }
 
 void
 nsComponentManagerImpl::ManifestManifest(ManifestProcessingContext& cx, int lineno, char *const * argv)
 {
     char* file = argv[0];
-
-    if (cx.mPath) {
-        nsCAutoString manifest(cx.mPath);
-        AppendFileToManifestPath(manifest, file);
-
-        RegisterJarManifest(cx.mType, cx.mReader, manifest.get(), cx.mChromeOnly);
-    }
-    else {
-#ifdef TRANSLATE_SLASHES
-        TranslateSlashes(file);
-#endif
-        nsCOMPtr<nsIFile> cfile;
-        cx.mFile->GetParent(getter_AddRefs(cfile));
-        nsCOMPtr<nsILocalFile> clfile = do_QueryInterface(cfile);
-
-        nsresult rv = clfile->AppendRelativeNativePath(nsDependentCString(file));
-        if (NS_FAILED(rv)) {
-            NS_WARNING("Couldn't append relative path?");
-            return;
-        }
-
-        RegisterManifestFile(cx.mType, clfile, cx.mChromeOnly);
-    }
+    FileLocation f(cx.mFile, file);
+    RegisterManifest(cx.mType, f, cx.mChromeOnly);
 }
 
 void
 nsComponentManagerImpl::ManifestBinaryComponent(ManifestProcessingContext& cx, int lineno, char *const * argv)
 {
-    if (cx.mPath) {
+    if (cx.mFile.IsZip()) {
         NS_WARNING("Cannot load binary components from a jar.");
-        LogMessageWithContext(cx.mFile, cx.mPath, lineno,
+        LogMessageWithContext(cx.mFile, lineno,
                               "Cannot load binary components from a jar.");
         return;
     }
 
-    char* file = argv[0];
-
-#ifdef TRANSLATE_SLASHES
-    TranslateSlashes(file);
-#endif
-
-    nsCOMPtr<nsIFile> cfile;
-    cx.mFile->GetParent(getter_AddRefs(cfile));
-    nsCOMPtr<nsILocalFile> clfile = do_QueryInterface(cfile);
+    FileLocation f(cx.mFile, argv[0]);
+    nsCString uri;
+    f.GetURIString(uri);
 
-    nsresult rv = clfile->AppendRelativeNativePath(nsDependentCString(file));
-    if (NS_FAILED(rv)) {
-        NS_WARNING("Couldn't append relative path?");
-        return;
-    }
-
-    nsCAutoString uri;
-    rv = net_GetURLSpecFromActualFile(clfile, uri);
-    if (NS_FAILED(rv)) {
-        NS_WARNING("net_GetURLSpecFromActualFile failed");
-        return;
-    }
     if (mKnownModules.Get(uri)) {
         NS_WARNING("Attempting to register a binary component twice.");
-        LogMessageWithContext(cx.mFile, cx.mPath, lineno,
+        LogMessageWithContext(cx.mFile, lineno,
                               "Attempting to register a binary component twice.");
         return;
     }
 
-    const mozilla::Module* m = mNativeModuleLoader.LoadModule(clfile);
+    const mozilla::Module* m = mNativeModuleLoader.LoadModule(f);
     // The native module loader should report an error here, we don't have to
     if (!m)
         return;
 
-    RegisterModule(m, clfile);
+    RegisterModule(m, &f);
 }
 
 void
 nsComponentManagerImpl::ManifestXPT(ManifestProcessingContext& cx, int lineno, char *const * argv)
 {
-    char* file = argv[0];
-
-    if (cx.mPath) {
-        nsCAutoString manifest(cx.mPath);
-        AppendFileToManifestPath(manifest, file);
-
-        nsCOMPtr<nsIInputStream> stream =
-            LoadEntry(cx.mReader, manifest.get());
-        if (!stream) {
-            NS_WARNING("Failed to load XPT file in a jar.");
-            return;
-        }
-
-        xptiInterfaceInfoManager::GetSingleton()
-            ->RegisterInputStream(stream);
+    FileLocation f(cx.mFile, argv[0]);
+    PRUint32 len;
+    FileLocation::Data data;
+    nsAutoArrayPtr<char> buf;
+    nsresult rv = f.GetData(data);
+    if (NS_SUCCEEDED(rv)) {
+        rv = data.GetSize(&len);
     }
-    else {
-#ifdef TRANSLATE_SLASHES
-        TranslateSlashes(file);
-#endif
-        nsCOMPtr<nsIFile> cfile;
-        cx.mFile->GetParent(getter_AddRefs(cfile));
-        nsCOMPtr<nsILocalFile> clfile = do_QueryInterface(cfile);
-
-        nsresult rv = clfile->AppendRelativeNativePath(nsDependentCString(file));
-        if (NS_FAILED(rv)) {
-            NS_WARNING("Couldn't append relative path?");
-            return;
-        }
-
+    if (NS_SUCCEEDED(rv)) {
+        buf = new char[len];
+        rv = data.Copy(buf, len);
+    }
+    if (NS_SUCCEEDED(rv)) {
         xptiInterfaceInfoManager::GetSingleton()
-            ->RegisterFile(clfile);
+            ->RegisterBuffer(buf, len);
+    } else {
+        nsCString uri;
+        f.GetURIString(uri);
+        LogMessage("Could not read '%s'.", uri.get());
     }
 }
 
 void
 nsComponentManagerImpl::ManifestComponent(ManifestProcessingContext& cx, int lineno, char *const * argv)
 {
     char* id = argv[0];
     char* file = argv[1];
 
     nsID cid;
     if (!cid.Parse(id)) {
-        LogMessageWithContext(cx.mFile, cx.mPath, lineno,
+        LogMessageWithContext(cx.mFile, lineno,
                               "Malformed CID: '%s'.", id);
         return;
     }
 
     ReentrantMonitorAutoEnter mon(mMon);
     nsFactoryEntry* f = mFactories.Get(cid);
     if (f) {
         char idstr[NSID_LENGTH];
         cid.ToProvidedString(idstr);
 
         nsCString existing;
         if (f->mModule)
             existing = f->mModule->Description();
         else
             existing = "<unknown module>";
 
-        LogMessageWithContext(cx.mFile, cx.mPath, lineno,
+        LogMessageWithContext(cx.mFile, lineno,
                               "Trying to re-register CID '%s' already registered by %s.",
                               idstr,
                               existing.get());
         return;
     }
 
     KnownModule* km;
-
-    if (cx.mPath) {
-        nsCAutoString manifest(cx.mPath);
-        AppendFileToManifestPath(manifest, file);
-
-        nsCAutoString hash;
-        nsresult rv = net_GetURLSpecFromActualFile(cx.mFile, hash);
-        if (NS_FAILED(rv)) {
-            NS_WARNING("net_GetURLSpecFromActualFile failed");
-            return;
-        }
-        hash.Insert("jar:", 0);
-        hash.Append("!/");
-        hash.Append(manifest);
+    FileLocation fl(cx.mFile, file);
 
-        km = mKnownModules.Get(hash);
-        if (!km) {
-            km = new KnownModule(cx.mFile, manifest);
-            mKnownModules.Put(hash, km);
-        }
-    }
-    else {
-#ifdef TRANSLATE_SLASHES
-        TranslateSlashes(file);
-#endif
-        nsCOMPtr<nsIFile> cfile;
-        cx.mFile->GetParent(getter_AddRefs(cfile));
-        nsCOMPtr<nsILocalFile> clfile = do_QueryInterface(cfile);
-
-        nsresult rv = clfile->AppendRelativeNativePath(nsDependentCString(file));
-        if (NS_FAILED(rv)) {
-            NS_WARNING("Couldn't append relative path?");
-            return;
-        }
-        nsCAutoString hash;
-        rv = net_GetURLSpecFromActualFile(clfile, hash);
-        if (NS_FAILED(rv)) {
-            NS_WARNING("net_GetURLSpecFromActualFile failed");
-            return;
-        }
-
-        km = mKnownModules.Get(hash);
-        if (!km) {
-            km = new KnownModule(clfile);
-            mKnownModules.Put(hash, km);
-        }
+    nsCString hash;
+    fl.GetURIString(hash);
+    km = mKnownModules.Get(hash);
+    if (!km) {
+        km = new KnownModule(fl);
+        mKnownModules.Put(hash, km);
     }
 
     void* place;
 
     PL_ARENA_ALLOCATE(place, &mArena, sizeof(nsCID));
     nsID* permanentCID = static_cast<nsID*>(place);
     *permanentCID = cid;
 
@@ -853,25 +657,25 @@ nsComponentManagerImpl::ManifestComponen
 void
 nsComponentManagerImpl::ManifestContract(ManifestProcessingContext& cx, int lineno, char *const * argv)
 {
     char* contract = argv[0];
     char* id = argv[1];
 
     nsID cid;
     if (!cid.Parse(id)) {
-        LogMessageWithContext(cx.mFile, cx.mPath, lineno,
+        LogMessageWithContext(cx.mFile, lineno,
                               "Malformed CID: '%s'.", id);
         return;
     }
 
     ReentrantMonitorAutoEnter mon(mMon);
     nsFactoryEntry* f = mFactories.Get(cid);
     if (!f) {
-        LogMessageWithContext(cx.mFile, cx.mPath, lineno,
+        LogMessageWithContext(cx.mFile, lineno,
                               "Could not map contract ID '%s' to CID %s because no implementation of the CID is registered.",
                               contract, id);
         return;
     }
 
     mContractIDs.Put(nsDependentCString(contract), f);
 }
 
@@ -886,61 +690,42 @@ nsComponentManagerImpl::ManifestCategory
         AddCategoryEntry(category, key, value);
 }
 
 void
 nsComponentManagerImpl::RereadChromeManifests(bool aChromeOnly)
 {
     for (PRUint32 i = 0; i < sModuleLocations->Length(); ++i) {
         ComponentLocation& l = sModuleLocations->ElementAt(i);
-        if (!l.jar) {
-            RegisterManifestFile(l.type, l.location, aChromeOnly);
-            continue;
-        }
-
-        nsresult rv;
-        nsCOMPtr<nsIZipReader> reader = do_CreateInstance(kZipReaderCID, &rv);
-        if (NS_SUCCEEDED(rv))
-            rv = reader->Open(l.location);
-        if (NS_SUCCEEDED(rv))
-            RegisterJarManifest(l.type, reader, "chrome.manifest", aChromeOnly);
+        RegisterManifest(l.type, l.location, aChromeOnly);
     }
 }
 
 bool
 nsComponentManagerImpl::KnownModule::EnsureLoader()
 {
     if (!mLoader) {
         nsCString extension;
-        if (!mPath.IsEmpty()) {
-            extension = mPath;
-            CutExtension(extension);
-        }
-        else {
-            extension = GetExtension(mFile);
-        }
-
+        mFile.GetURIString(extension);
+        CutExtension(extension);
         mLoader = nsComponentManagerImpl::gComponentManager->LoaderForExtension(extension);
     }
     return !!mLoader;
 }
 
 bool
 nsComponentManagerImpl::KnownModule::Load()
 {
     if (mFailed)
         return false;
     if (!mModule) {
         if (!EnsureLoader())
             return false;
 
-        if (!mPath.IsEmpty())
-            mModule = mLoader->LoadModuleFromJAR(mFile, mPath);
-        else
-            mModule = mLoader->LoadModule(mFile);
+        mModule = mLoader->LoadModule(mFile);
 
         if (!mModule) {
             mFailed = true;
             return false;
         }
     }
     if (!mLoaded) {
         if (mModule->loadProc) {
@@ -954,24 +739,18 @@ nsComponentManagerImpl::KnownModule::Loa
     }
     return true;
 }
 
 nsCString
 nsComponentManagerImpl::KnownModule::Description() const
 {
     nsCString s;
-    if (!mPath.IsEmpty()) {
-        mFile->GetNativePath(s);
-        s.Insert(NS_LITERAL_CSTRING("jar:"), 0);
-        s.AppendLiteral("!/");
-        s.Append(mPath);
-    }
-    else if (mFile)
-        mFile->GetNativePath(s);
+    if (mFile)
+        mFile.GetURIString(s);
     else
         s = "<static module>";
     return s;
 }
 
 nsresult nsComponentManagerImpl::Shutdown(void)
 {
     NS_TIME_FUNCTION;
@@ -2045,77 +1824,64 @@ nsComponentManagerImpl::AddBootstrappedM
 
 NS_IMETHODIMP
 nsComponentManagerImpl::RemoveBootstrappedManifestLocation(nsILocalFile* aLocation)
 {
   nsCOMPtr<nsIChromeRegistry> cr = mozilla::services::GetChromeRegistryService();
   if (!cr)
     return NS_ERROR_FAILURE;
 
-  bool isJar = false;
   nsCOMPtr<nsILocalFile> manifest;
   nsString path;
   nsresult rv = aLocation->GetPath(path);
   if (NS_FAILED(rv))
     return rv;
 
+  nsComponentManagerImpl::ComponentLocation elem;
+  elem.type = NS_BOOTSTRAPPED_LOCATION;
+
   if (Substring(path, path.Length() - 4).Equals(NS_LITERAL_STRING(".xpi"))) {
-    isJar = true;
-    manifest = aLocation;
+    elem.location.Init(aLocation, "chrome.manifest");
   } else {
-    manifest = CloneAndAppend(aLocation, NS_LITERAL_CSTRING("chrome.manifest"));
+    nsCOMPtr<nsILocalFile> lf = CloneAndAppend(aLocation, NS_LITERAL_CSTRING("chrome.manifest"));
+    elem.location.Init(lf);
   }
 
-  nsComponentManagerImpl::ComponentLocation elem = {
-    NS_BOOTSTRAPPED_LOCATION,
-    manifest,
-    isJar
-  };
-
   // Remove reference.
   nsComponentManagerImpl::sModuleLocations->RemoveElement(elem, ComponentLocationComparator());
 
   rv = cr->CheckForNewChrome();
   return rv;
 }
 
 EXPORT_XPCOM_API(nsresult)
 XRE_AddManifestLocation(NSLocationType aType, nsILocalFile* aLocation)
 {
     nsComponentManagerImpl::InitializeModuleLocations();
     nsComponentManagerImpl::ComponentLocation* c = 
         nsComponentManagerImpl::sModuleLocations->AppendElement();
     c->type = aType;
-    c->location = aLocation;
-    c->jar = false;
+    c->location.Init(aLocation);
 
     if (nsComponentManagerImpl::gComponentManager &&
         nsComponentManagerImpl::NORMAL == nsComponentManagerImpl::gComponentManager->mStatus)
-        nsComponentManagerImpl::gComponentManager->RegisterManifestFile(aType, aLocation, false);
+        nsComponentManagerImpl::gComponentManager->RegisterManifest(aType, c->location, false);
 
     return NS_OK;
 }
 
 EXPORT_XPCOM_API(nsresult)
 XRE_AddJarManifestLocation(NSLocationType aType, nsILocalFile* aLocation)
 {
     nsComponentManagerImpl::InitializeModuleLocations();
     nsComponentManagerImpl::ComponentLocation* c = 
         nsComponentManagerImpl::sModuleLocations->AppendElement();
+
     c->type = aType;
-    c->location = aLocation;
-    c->jar = true;
-
-    if (!nsComponentManagerImpl::gComponentManager ||
-        nsComponentManagerImpl::NORMAL != nsComponentManagerImpl::gComponentManager->mStatus)
-        return NS_OK;
+    c->location.Init(aLocation, "chrome.manifest");
 
-    nsresult rv;
-    nsCOMPtr<nsIZipReader> reader = do_CreateInstance(kZipReaderCID, &rv);
-    NS_ENSURE_SUCCESS(rv, rv);
-
-    rv = reader->Open(c->location);
-    if (NS_SUCCEEDED(rv))
-        nsComponentManagerImpl::gComponentManager->RegisterJarManifest(aType, reader, "chrome.manifest", false);
+    if (nsComponentManagerImpl::gComponentManager &&
+        nsComponentManagerImpl::NORMAL == nsComponentManagerImpl::gComponentManager->mStatus)
+        nsComponentManagerImpl::gComponentManager->RegisterManifest(aType, c->location, false);
 
     return NS_OK;
 }
 

--- a/xpcom/components/nsComponentManager.h
+++ b/xpcom/components/nsComponentManager.h
@@ -62,17 +62,16 @@
 #include "plarena.h"
 #include "nsCOMArray.h"
 #include "nsDataHashtable.h"
 #include "nsInterfaceHashtable.h"
 #include "nsClassHashtable.h"
 #include "nsTArray.h"
 
 #include "mozilla/Omnijar.h"
-#include "nsIZipReader.h"
 
 struct nsFactoryEntry;
 class nsIServiceManager;
 struct PRThread;
 
 #define NS_COMPONENTMANAGER_CID                      \
 { /* 91775d60-d5dc-11d2-92fb-00e09805570f */         \
     0x91775d60,                                      \
@@ -153,66 +152,55 @@ public:
     mozilla::ReentrantMonitor mMon;
 
     static void InitializeStaticModules();
     static void InitializeModuleLocations();
 
     struct ComponentLocation
     {
         NSLocationType type;
-        nsCOMPtr<nsILocalFile> location;
-        bool jar;
+        mozilla::FileLocation location;
     };
 
     class ComponentLocationComparator
     {
     public:
       bool Equals(const ComponentLocation& a, const ComponentLocation& b) const
       {
-        if (a.type == b.type && a.jar == b.jar) {
-          bool res;
-          nsresult rv = a.location->Equals(b.location, &res);
-          NS_ASSERTION(NS_SUCCEEDED(rv), "Error comparing locations");
-          return res;
-        }
-
-        return false;
+        return (a.type == b.type && a.location.Equals(b.location));
       }
     };
 
     static nsTArray<const mozilla::Module*>* sStaticModules;
     static nsTArray<ComponentLocation>* sModuleLocations;
 
     nsNativeModuleLoader mNativeModuleLoader;
 
     class KnownModule
     {
     public:
         /**
          * Static or binary module.
          */
-        KnownModule(const mozilla::Module* aModule, nsILocalFile* aFile)
+        KnownModule(const mozilla::Module* aModule, mozilla::FileLocation &aFile)
             : mModule(aModule)
             , mFile(aFile)
             , mLoaded(false)
             , mFailed(false)
         { }
 
-        KnownModule(nsILocalFile* aFile)
-            : mModule(NULL)
-            , mFile(aFile)
-            , mLoader(NULL)
+        KnownModule(const mozilla::Module* aModule)
+            : mModule(aModule)
             , mLoaded(false)
             , mFailed(false)
         { }
 
-        KnownModule(nsILocalFile* aFile, const nsACString& aPath)
+        KnownModule(mozilla::FileLocation &aFile)
             : mModule(NULL)
             , mFile(aFile)
-            , mPath(aPath)
             , mLoader(NULL)
             , mLoaded(false)
             , mFailed(false)
         { }
 
         ~KnownModule()
         {
             if (mLoaded && mModule->unloadProc)
@@ -230,68 +218,49 @@ public:
         /**
          * For error logging, get a description of this module, either the
          * file path, or <static module>.
          */
         nsCString Description() const;
 
     private:
         const mozilla::Module* mModule;
-        nsCOMPtr<nsILocalFile> mFile;
-        nsCString mPath;
+        mozilla::FileLocation mFile;
         nsCOMPtr<mozilla::ModuleLoader> mLoader;
         bool mLoaded;
         bool mFailed;
     };
 
     // The KnownModule is kept alive by these members, it is
     // referenced by pointer from the factory entries.
     nsTArray< nsAutoPtr<KnownModule> > mKnownStaticModules;
     // The key is the URI string of the module
     nsClassHashtable<nsCStringHashKey, KnownModule> mKnownModules;
 
     void RegisterModule(const mozilla::Module* aModule,
-                        nsILocalFile* aFile);
+                        mozilla::FileLocation* aFile);
     void RegisterCIDEntry(const mozilla::Module::CIDEntry* aEntry,
                           KnownModule* aModule);
     void RegisterContractID(const mozilla::Module::ContractIDEntry* aEntry);
 
-    void RegisterJarManifest(NSLocationType aType, nsIZipReader* aReader,
-                             const char* aPath, bool aChromeOnly);
-
-    void RegisterManifestFile(NSLocationType aType, nsILocalFile* aFile,
-                              bool aChromeOnly);
+    void RegisterManifest(NSLocationType aType, mozilla::FileLocation &aFile,
+                          bool aChromeOnly);
 
     struct ManifestProcessingContext
     {
-        ManifestProcessingContext(NSLocationType aType, nsILocalFile* aFile, bool aChromeOnly)
+        ManifestProcessingContext(NSLocationType aType, mozilla::FileLocation &aFile, bool aChromeOnly)
             : mType(aType)
             , mFile(aFile)
-            , mPath(NULL)
             , mChromeOnly(aChromeOnly)
         { }
 
-        ManifestProcessingContext(NSLocationType aType, nsIZipReader* aReader, const char* aPath, bool aChromeOnly)
-            : mType(aType)
-            , mReader(aReader)
-            , mPath(aPath)
-            , mChromeOnly(aChromeOnly)
-        {
-            nsCOMPtr<nsIFile> file;
-            aReader->GetFile(getter_AddRefs(file));
-            nsCOMPtr<nsILocalFile> localfile = do_QueryInterface(file);
-            mFile = localfile;
-        }
-
         ~ManifestProcessingContext() { }
 
         NSLocationType mType;
-        nsILocalFile* mFile;
-        nsIZipReader* mReader;
-        const char* mPath;
+        mozilla::FileLocation mFile;
         bool mChromeOnly;
     };
 
     void ManifestManifest(ManifestProcessingContext& cx, int lineno, char *const * argv);
     void ManifestBinaryComponent(ManifestProcessingContext& cx, int lineno, char *const * argv);
     void ManifestXPT(ManifestProcessingContext& cx, int lineno, char *const * argv);
     void ManifestComponent(ManifestProcessingContext& cx, int lineno, char *const * argv);
     void ManifestContract(ManifestProcessingContext& cx, int lineno, char* const * argv);

--- a/xpcom/components/nsNativeComponentLoader.cpp
+++ b/xpcom/components/nsNativeComponentLoader.cpp
@@ -78,16 +78,18 @@
 #include <lib$routines.h>
 #include <ssdef.h>
 #endif
 
 #ifdef DEBUG
 #define IMPLEMENT_BREAK_AFTER_LOAD
 #endif
 
+using namespace mozilla;
+
 static PRLogModuleInfo *nsNativeModuleLoaderLog =
     PR_NewLogModule("nsNativeModuleLoader");
 
 #define LOG(level, args) PR_LOG(nsNativeModuleLoaderLog, level, args)
 
 NS_IMPL_QUERY_INTERFACE1(nsNativeModuleLoader, 
                          mozilla::ModuleLoader)
 
@@ -105,84 +107,89 @@ nsNativeModuleLoader::Init()
 
     return mLibraries.Init() ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
 }
 
 class LoadModuleMainThreadRunnable : public nsRunnable
 {
 public:
     LoadModuleMainThreadRunnable(nsNativeModuleLoader* loader,
-                                 nsILocalFile* file)
+                                 FileLocation &file)
         : mLoader(loader)
         , mFile(file)
         , mResult(NULL)
     { }
 
     NS_IMETHOD Run()
     {
         mResult = mLoader->LoadModule(mFile);
         return NS_OK;
     }
 
     nsRefPtr<nsNativeModuleLoader> mLoader;
-    nsCOMPtr<nsILocalFile> mFile;
+    FileLocation mFile;
     const mozilla::Module* mResult;
 };
 
 const mozilla::Module*
-nsNativeModuleLoader::LoadModule(nsILocalFile* aFile)
+nsNativeModuleLoader::LoadModule(FileLocation &aFile)
 {
+    if (aFile.IsZip()) {
+        NS_ERROR("Binary components cannot be loaded from JARs");
+        return NULL;
+    }
+    nsCOMPtr<nsILocalFile> file = aFile.GetBaseFile();
     nsresult rv;
 
     if (!NS_IsMainThread()) {
         // If this call is off the main thread, synchronously proxy it
         // to the main thread.
         nsRefPtr<LoadModuleMainThreadRunnable> r = new LoadModuleMainThreadRunnable(this, aFile);
         NS_DispatchToMainThread(r, NS_DISPATCH_SYNC);
         return r->mResult;
     }
 
-    nsCOMPtr<nsIHashable> hashedFile(do_QueryInterface(aFile));
+    nsCOMPtr<nsIHashable> hashedFile(do_QueryInterface(file));
     if (!hashedFile) {
         NS_ERROR("nsIFile is not nsIHashable");
         return NULL;
     }
 
     nsCAutoString filePath;
-    aFile->GetNativePath(filePath);
+    file->GetNativePath(filePath);
 
     NativeLoadData data;
 
     if (mLibraries.Get(hashedFile, &data)) {
         NS_ASSERTION(data.module, "Corrupt mLibraries hash");
         LOG(PR_LOG_DEBUG,
             ("nsNativeModuleLoader::LoadModule(\"%s\") - found in cache",
              filePath.get()));
         return data.module;
     }
 
     // We haven't loaded this module before
 
-    rv = aFile->Load(&data.library);
+    rv = file->Load(&data.library);
 
     if (NS_FAILED(rv)) {
         char errorMsg[1024] = "<unknown; can't get error from NSPR>";
 
         if (PR_GetErrorTextLength() < (int) sizeof(errorMsg))
             PR_GetErrorText(errorMsg);
 
         LogMessage("Failed to load native module at path '%s': (%lx) %s",
                    filePath.get(), rv, errorMsg);
 
         return NULL;
     }
 
 #ifdef IMPLEMENT_BREAK_AFTER_LOAD
     nsCAutoString leafName;
-    aFile->GetNativeLeafName(leafName);
+    file->GetNativeLeafName(leafName);
 
     char *env = getenv("XPCOM_BREAK_ON_LOAD");
     char *blist;
     if (env && *env && (blist = strdup(env))) {
         char *nextTok = blist;
         while (char *token = NS_strtok(":", &nextTok)) {
             if (leafName.Find(token, true) != kNotFound) {
                 NS_BREAK();
@@ -209,23 +216,16 @@ nsNativeModuleLoader::LoadModule(nsILoca
         PR_UnloadLibrary(data.library);
         return NULL;
     }
         
     mLibraries.Put(hashedFile, data); // infallible
     return data.module;
 }
 
-const mozilla::Module*
-nsNativeModuleLoader::LoadModuleFromJAR(nsILocalFile* aJARFile, const nsACString &aPath)
-{
-    NS_ERROR("Binary components cannot be loaded from JARs");
-    return NULL;
-}
-
 PLDHashOperator
 nsNativeModuleLoader::ReleaserFunc(nsIHashable* aHashedFile,
                                    NativeLoadData& aLoadData, void*)
 {
     aLoadData.module = nsnull;
     return PL_DHASH_NEXT;
 }
 

--- a/xpcom/components/nsNativeComponentLoader.h
+++ b/xpcom/components/nsNativeComponentLoader.h
@@ -48,19 +48,17 @@
 class nsNativeModuleLoader : public mozilla::ModuleLoader
 {
  public:
     NS_DECL_ISUPPORTS_INHERITED
 
     nsNativeModuleLoader() {}
     ~nsNativeModuleLoader() {}
 
-    NS_OVERRIDE virtual const mozilla::Module* LoadModule(nsILocalFile* aFile);
-    NS_OVERRIDE virtual const mozilla::Module* LoadModuleFromJAR(nsILocalFile* aJARFile,
-                                                                 const nsACString& aPath);
+    NS_OVERRIDE virtual const mozilla::Module* LoadModule(mozilla::FileLocation &aFile);
 
     nsresult Init();
 
     void UnloadLibraries();
 
  private:
     struct NativeLoadData
     {

--- a/xpcom/reflect/xptinfo/src/xptiInterfaceInfoManager.cpp
+++ b/xpcom/reflect/xptinfo/src/xptiInterfaceInfoManager.cpp
@@ -92,116 +92,35 @@ xptiInterfaceInfoManager::~xptiInterface
     mWorkingSet.InvalidateInterfaceInfos();
 
     gInterfaceInfoManager = nsnull;
 #ifdef DEBUG
     gCallCount = 0;
 #endif
 }
 
-XPTHeader* 
-xptiInterfaceInfoManager::ReadXPTFile(nsILocalFile* aFile)
+void
+xptiInterfaceInfoManager::RegisterBuffer(char *buf, PRUint32 length)
 {
-    mozilla::AutoFDClose fd;
-    if (NS_FAILED(aFile->OpenNSPRFileDesc(PR_RDONLY, 0444, &fd)) || !fd)
-        return NULL;
-
-    PRFileInfo64 fileInfo;
-    if (PR_SUCCESS != PR_GetOpenFileInfo64(fd, &fileInfo))
-        return NULL;
-
-    if (fileInfo.size > PRInt64(PR_INT32_MAX))
-        return NULL;
-
-    nsAutoArrayPtr<char> whole(new char[PRInt32(fileInfo.size)]);
-    if (!whole)
-        return nsnull;
-
-    for (PRInt32 totalRead = 0; totalRead < fileInfo.size; ) {
-        PRInt32 read = PR_Read(fd, whole + totalRead, PRInt32(fileInfo.size));
-        if (read < 0)
-            return NULL;
-        totalRead += read;
-    }
-
-    XPTState* state = XPT_NewXDRState(XPT_DECODE, whole,
-                                      PRInt32(fileInfo.size));
+    XPTState *state = XPT_NewXDRState(XPT_DECODE, buf, length);
+    if (!state)
+        return;
 
     XPTCursor cursor;
     if (!XPT_MakeCursor(state, XPT_HEADER, 0, &cursor)) {
         XPT_DestroyXDRState(state);
-        return NULL;
+        return;
     }
-    
+
     XPTHeader *header = nsnull;
-    if (!XPT_DoHeader(gXPTIStructArena, &cursor, &header)) {
-        XPT_DestroyXDRState(state);
-        return NULL;
+    if (XPT_DoHeader(gXPTIStructArena, &cursor, &header)) {
+        RegisterXPTHeader(header);
     }
 
     XPT_DestroyXDRState(state);
-
-    return header;
-}
-
-XPTHeader*
-xptiInterfaceInfoManager::ReadXPTFileFromInputStream(nsIInputStream *stream)
-{
-    PRUint32 flen;
-    stream->Available(&flen);
-    
-    nsAutoArrayPtr<char> whole(new char[flen]);
-    if (!whole)
-        return nsnull;
-
-    for (PRUint32 totalRead = 0; totalRead < flen; ) {
-        PRUint32 avail;
-        PRUint32 read;
-
-        if (NS_FAILED(stream->Available(&avail)))
-            return NULL;
-
-        if (avail > flen)
-            return NULL;
-
-        if (NS_FAILED(stream->Read(whole+totalRead, avail, &read)))
-            return NULL;
-
-        totalRead += read;
-    }
-    
-    XPTState *state = XPT_NewXDRState(XPT_DECODE, whole, flen);
-    if (!state)
-        return NULL;
-    
-    XPTCursor cursor;
-    if (!XPT_MakeCursor(state, XPT_HEADER, 0, &cursor)) {
-        XPT_DestroyXDRState(state);
-        return NULL;
-    }
-    
-    XPTHeader *header = nsnull;
-    if (!XPT_DoHeader(gXPTIStructArena, &cursor, &header)) {
-        XPT_DestroyXDRState(state);
-        return NULL;
-    }
-
-    XPT_DestroyXDRState(state);
-
-    return header;
-}
-
-void
-xptiInterfaceInfoManager::RegisterFile(nsILocalFile* aFile)
-{
-    XPTHeader* header = ReadXPTFile(aFile);
-    if (!header)
-        return;
-
-    RegisterXPTHeader(header);
 }
 
 void
 xptiInterfaceInfoManager::RegisterXPTHeader(XPTHeader* aHeader)
 {
     if (aHeader->major_version >= XPT_MAJOR_INCOMPATIBLE_VERSION) {
         NS_ASSERTION(!aHeader->num_interfaces,"bad libxpt");
         LOG_AUTOREG(("      file is version %d.%d  Type file of version %d.0 or higher can not be read.\n", (int)header->major_version, (int)header->minor_version, (int)XPT_MAJOR_INCOMPATIBLE_VERSION));
@@ -210,24 +129,16 @@ xptiInterfaceInfoManager::RegisterXPTHea
     xptiTypelibGuts* typelib = xptiTypelibGuts::Create(aHeader);
 
     ReentrantMonitorAutoEnter monitor(mWorkingSet.mTableReentrantMonitor);
     for(PRUint16 k = 0; k < aHeader->num_interfaces; k++)
         VerifyAndAddEntryIfNew(aHeader->interface_directory + k, k, typelib);
 }
 
 void
-xptiInterfaceInfoManager::RegisterInputStream(nsIInputStream* aStream)
-{
-    XPTHeader* header = ReadXPTFileFromInputStream(aStream);
-    if (header)
-        RegisterXPTHeader(header);
-}
-
-void
 xptiInterfaceInfoManager::VerifyAndAddEntryIfNew(XPTInterfaceDirectoryEntry* iface,
                                                  PRUint16 idx,
                                                  xptiTypelibGuts* typelib)
 {
     if (!iface->interface_descriptor)
         return;
 
     // The number of maximum methods is not arbitrary. It is the same value as

--- a/xpcom/reflect/xptinfo/src/xptiprivate.h
+++ b/xpcom/reflect/xptinfo/src/xptiprivate.h
@@ -439,18 +439,17 @@ class xptiInterfaceInfoManager
     typedef mozilla::ReentrantMonitor ReentrantMonitor;
     typedef mozilla::Mutex Mutex;
 
 public:
     // GetSingleton() is infallible
     static xptiInterfaceInfoManager* GetSingleton();
     static void FreeInterfaceInfoManager();
 
-    void RegisterFile(nsILocalFile* aFile);
-    void RegisterInputStream(nsIInputStream* aStream);
+    void RegisterBuffer(char *buf, PRUint32 length);
 
     xptiWorkingSet*  GetWorkingSet() {return &mWorkingSet;}
 
     static Mutex& GetResolveLock(xptiInterfaceInfoManager* self = nsnull) 
     {
         self = self ? self : GetSingleton();
         return self->mResolveLock;
     }
@@ -458,19 +457,16 @@ public:
     xptiInterfaceEntry* GetInterfaceEntryForIID(const nsIID *iid);
 
 private:
     xptiInterfaceInfoManager();
     ~xptiInterfaceInfoManager();
 
     void RegisterXPTHeader(XPTHeader* aHeader);
                           
-    XPTHeader* ReadXPTFile(nsILocalFile* aFile);
-    XPTHeader* ReadXPTFileFromInputStream(nsIInputStream *stream);
-
     // idx is the index of this interface in the XPTHeader
     void VerifyAndAddEntryIfNew(XPTInterfaceDirectoryEntry* iface,
                                 PRUint16 idx,
                                 xptiTypelibGuts* typelib);
 
 private:
     xptiWorkingSet               mWorkingSet;
     Mutex                        mResolveLock;