diff -r 000000000000 -r 6474c204b198 xpcom/io/nsDirectoryService.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/xpcom/io/nsDirectoryService.cpp	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,894 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ * vim: sw=4 ts=4 sts=4 et
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/ArrayUtils.h"
+
+#include "nsCOMPtr.h"
+#include "nsAutoPtr.h"
+#include "nsDirectoryService.h"
+#include "nsDirectoryServiceDefs.h"
+#include "nsLocalFile.h"
+#include "nsDebug.h"
+#include "nsStaticAtom.h"
+#include "nsEnumeratorUtils.h"
+
+#include "nsICategoryManager.h"
+#include "nsISimpleEnumerator.h"
+#include "nsIStringEnumerator.h"
+
+#if defined(XP_WIN)
+#include <windows.h>
+#include <shlobj.h>
+#include <stdlib.h>
+#include <stdio.h>
+#elif defined(XP_UNIX)
+#include <unistd.h>
+#include <stdlib.h>
+#include <sys/param.h>
+#include "prenv.h"
+#ifdef MOZ_WIDGET_COCOA
+#include <CoreServices/CoreServices.h>
+#include <Carbon/Carbon.h>
+#endif
+#endif
+
+#include "SpecialSystemDirectory.h"
+#include "nsAppFileLocationProvider.h"
+
+using namespace mozilla;
+
+// define home directory
+// For Windows platform, We are choosing Appdata folder as HOME
+#if defined (XP_WIN)
+#define HOME_DIR NS_WIN_APPDATA_DIR
+#elif defined (MOZ_WIDGET_COCOA)
+#define HOME_DIR NS_OSX_HOME_DIR
+#elif defined (XP_UNIX)
+#define HOME_DIR NS_UNIX_HOME_DIR
+#endif
+
+//----------------------------------------------------------------------------------------
+nsresult 
+nsDirectoryService::GetCurrentProcessDirectory(nsIFile** aFile)
+//----------------------------------------------------------------------------------------
+{
+    if (NS_WARN_IF(!aFile))
+        return NS_ERROR_INVALID_ARG;
+    *aFile = nullptr;
+    
+   //  Set the component registry location:
+    if (!gService)
+        return NS_ERROR_FAILURE;
+
+    nsresult rv; 
+ 
+    nsCOMPtr<nsIProperties> dirService;
+    rv = nsDirectoryService::Create(nullptr, 
+                                    NS_GET_IID(nsIProperties), 
+                                    getter_AddRefs(dirService));  // needs to be around for life of product
+    if (NS_FAILED(rv))
+        return rv;
+
+    if (dirService)
+    {
+      nsCOMPtr <nsIFile> aLocalFile;
+      dirService->Get(NS_XPCOM_INIT_CURRENT_PROCESS_DIR, NS_GET_IID(nsIFile), getter_AddRefs(aLocalFile));
+      if (aLocalFile)
+      {
+        *aFile = aLocalFile;
+        NS_ADDREF(*aFile);
+        return NS_OK;
+      }
+    }
+
+    nsLocalFile* localFile = new nsLocalFile;
+
+    if (localFile == nullptr)
+        return NS_ERROR_OUT_OF_MEMORY;
+    NS_ADDREF(localFile);
+
+
+
+#ifdef XP_WIN
+    wchar_t buf[MAX_PATH + 1];
+    SetLastError(ERROR_SUCCESS);
+    if (GetModuleFileNameW(0, buf, mozilla::ArrayLength(buf)) &&
+        GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
+        // chop off the executable name by finding the rightmost backslash
+        wchar_t* lastSlash = wcsrchr(buf, L'\\');
+        if (lastSlash)
+            *(lastSlash + 1) = L'\0';
+
+        localFile->InitWithPath(nsDependentString(buf));
+        *aFile = localFile;
+        return NS_OK;
+    }
+
+#elif defined(MOZ_WIDGET_COCOA)
+    // Works even if we're not bundled.
+    CFBundleRef appBundle = CFBundleGetMainBundle();
+    if (appBundle != nullptr)
+    {
+        CFURLRef bundleURL = CFBundleCopyExecutableURL(appBundle);
+        if (bundleURL != nullptr)
+        {
+            CFURLRef parentURL = CFURLCreateCopyDeletingLastPathComponent(kCFAllocatorDefault, bundleURL);
+            if (parentURL)
+            {
+                // Pass true for the "resolveAgainstBase" arg to CFURLGetFileSystemRepresentation.
+                // This will resolve the relative portion of the CFURL against it base, giving a full
+                // path, which CFURLCopyFileSystemPath doesn't do.
+                char buffer[PATH_MAX];
+                if (CFURLGetFileSystemRepresentation(parentURL, true, (UInt8 *)buffer, sizeof(buffer)))
+                {
+#ifdef DEBUG_conrad
+                    printf("nsDirectoryService - CurrentProcessDir is: %s\n", buffer);
+#endif
+                    rv = localFile->InitWithNativePath(nsDependentCString(buffer));
+                    if (NS_SUCCEEDED(rv))
+                        *aFile = localFile;
+                }
+                CFRelease(parentURL);
+            }
+            CFRelease(bundleURL);
+        }
+    }
+    
+    NS_ASSERTION(*aFile, "nsDirectoryService - Could not determine CurrentProcessDir.\n");
+    if (*aFile)
+        return NS_OK;
+
+#elif defined(XP_UNIX)
+
+    // In the absence of a good way to get the executable directory let
+    // us try this for unix:
+    //    - if MOZILLA_FIVE_HOME is defined, that is it
+    //    - else give the current directory
+    char buf[MAXPATHLEN];
+
+    // The MOZ_DEFAULT_MOZILLA_FIVE_HOME variable can be set at configure time with
+    // a --with-default-mozilla-five-home=foo autoconf flag.
+    // 
+    // The idea here is to allow for builds that have a default MOZILLA_FIVE_HOME
+    // regardless of the environment.  This makes it easier to write apps that
+    // embed mozilla without having to worry about setting up the environment 
+    //
+    // We do this by putenv()ing the default value into the environment.  Note that
+    // we only do this if it is not already set.
+#ifdef MOZ_DEFAULT_MOZILLA_FIVE_HOME
+    const char *home = PR_GetEnv("MOZILLA_FIVE_HOME");
+    if (!home || !*home)
+    {
+        putenv("MOZILLA_FIVE_HOME=" MOZ_DEFAULT_MOZILLA_FIVE_HOME);
+    }
+#endif
+
+    char *moz5 = PR_GetEnv("MOZILLA_FIVE_HOME");
+    if (moz5 && *moz5)
+    {
+        if (realpath(moz5, buf)) {
+            localFile->InitWithNativePath(nsDependentCString(buf));
+            *aFile = localFile;
+            return NS_OK;
+        }
+    }
+#if defined(DEBUG)
+    static bool firstWarning = true;
+
+    if((!moz5 || !*moz5) && firstWarning) {
+        // Warn that MOZILLA_FIVE_HOME not set, once.
+        printf("Warning: MOZILLA_FIVE_HOME not set.\n");
+        firstWarning = false;
+    }
+#endif /* DEBUG */
+
+    // Fall back to current directory.
+    if (getcwd(buf, sizeof(buf)))
+    {
+        localFile->InitWithNativePath(nsDependentCString(buf));
+        *aFile = localFile;
+        return NS_OK;
+    }
+
+#endif
+    
+    NS_RELEASE(localFile);
+
+    NS_ERROR("unable to get current process directory");
+    return NS_ERROR_FAILURE;
+} // GetCurrentProcessDirectory()
+
+nsDirectoryService* nsDirectoryService::gService = nullptr;
+
+nsDirectoryService::nsDirectoryService()
+    : mHashtable(256)
+{
+}
+
+nsresult
+nsDirectoryService::Create(nsISupports *outer, REFNSIID aIID, void **aResult)
+{
+    if (NS_WARN_IF(!aResult))
+        return NS_ERROR_INVALID_ARG;
+    if (NS_WARN_IF(outer))
+        return NS_ERROR_NO_AGGREGATION;
+
+    if (!gService)
+    {
+        return NS_ERROR_NOT_INITIALIZED;
+    }
+
+    return gService->QueryInterface(aIID, aResult);
+}
+
+#define DIR_ATOM(name_, value_) nsIAtom* nsDirectoryService::name_ = nullptr;
+#include "nsDirectoryServiceAtomList.h"
+#undef DIR_ATOM
+
+#define DIR_ATOM(name_, value_) NS_STATIC_ATOM_BUFFER(name_##_buffer, value_)
+#include "nsDirectoryServiceAtomList.h"
+#undef DIR_ATOM
+
+static const nsStaticAtom directory_atoms[] = {
+#define DIR_ATOM(name_, value_) NS_STATIC_ATOM(name_##_buffer, &nsDirectoryService::name_),
+#include "nsDirectoryServiceAtomList.h"
+#undef DIR_ATOM
+};    
+
+NS_IMETHODIMP
+nsDirectoryService::Init()
+{
+    NS_NOTREACHED("nsDirectoryService::Init() for internal use only!");
+    return NS_OK;
+}
+
+void
+nsDirectoryService::RealInit()
+{
+    NS_ASSERTION(!gService, 
+                 "nsDirectoryService::RealInit Mustn't initialize twice!");
+
+    nsRefPtr<nsDirectoryService> self = new nsDirectoryService();
+
+    NS_RegisterStaticAtoms(directory_atoms);
+    
+    // Let the list hold the only reference to the provider.
+    nsAppFileLocationProvider *defaultProvider = new nsAppFileLocationProvider;
+    self->mProviders.AppendElement(defaultProvider);
+
+    self.swap(gService);
+}
+
+nsDirectoryService::~nsDirectoryService()
+{
+}
+
+NS_IMPL_ISUPPORTS(nsDirectoryService, nsIProperties, nsIDirectoryService, nsIDirectoryServiceProvider, nsIDirectoryServiceProvider2)
+
+
+NS_IMETHODIMP
+nsDirectoryService::Undefine(const char* prop)
+{
+    if (NS_WARN_IF(!prop))
+        return NS_ERROR_INVALID_ARG;
+
+    nsDependentCString key(prop);
+    if (!mHashtable.Get(key, nullptr))
+        return NS_ERROR_FAILURE;
+
+    mHashtable.Remove(key);
+    return NS_OK;
+ }
+
+NS_IMETHODIMP
+nsDirectoryService::GetKeys(uint32_t *count, char ***keys)
+{
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+struct FileData
+{
+  FileData(const char* aProperty,
+           const nsIID& aUUID) :
+    property(aProperty),
+    data(nullptr),
+    persistent(true),
+    uuid(aUUID) {}
+    
+  const char*   property;
+  nsISupports*  data;
+  bool          persistent;
+  const nsIID&  uuid;
+};
+
+static bool FindProviderFile(nsIDirectoryServiceProvider* aElement,
+                             FileData* aData)
+{
+  nsresult rv;
+  if (aData->uuid.Equals(NS_GET_IID(nsISimpleEnumerator))) {
+      // Not all providers implement this iface
+      nsCOMPtr<nsIDirectoryServiceProvider2> prov2 = do_QueryInterface(aElement);
+      if (prov2)
+      {
+          nsCOMPtr<nsISimpleEnumerator> newFiles;
+          rv = prov2->GetFiles(aData->property, getter_AddRefs(newFiles));
+          if (NS_SUCCEEDED(rv) && newFiles) {
+              if (aData->data) {
+                  nsCOMPtr<nsISimpleEnumerator> unionFiles;
+
+                  NS_NewUnionEnumerator(getter_AddRefs(unionFiles),
+                                        (nsISimpleEnumerator*) aData->data, newFiles);
+
+                  if (unionFiles)
+                      unionFiles.swap(* (nsISimpleEnumerator**) &aData->data);
+              }
+              else
+              {
+                  NS_ADDREF(aData->data = newFiles);
+              }
+                  
+              aData->persistent = false; // Enumerators can never be persistent
+              return rv == NS_SUCCESS_AGGREGATE_RESULT;
+          }
+      }
+  }
+  else
+  {
+      rv = aElement->GetFile(aData->property, &aData->persistent,
+                             (nsIFile **)&aData->data);
+      if (NS_SUCCEEDED(rv) && aData->data)
+          return false;
+  }
+
+  return true;
+}
+
+NS_IMETHODIMP
+nsDirectoryService::Get(const char* prop, const nsIID & uuid, void* *result)
+{
+    if (NS_WARN_IF(!prop))
+        return NS_ERROR_INVALID_ARG;
+
+    nsDependentCString key(prop);
+
+    nsCOMPtr<nsIFile> cachedFile = mHashtable.Get(key);
+
+    if (cachedFile) {
+        nsCOMPtr<nsIFile> cloneFile;
+        cachedFile->Clone(getter_AddRefs(cloneFile));
+        return cloneFile->QueryInterface(uuid, result);
+    }
+
+    // it is not one of our defaults, lets check any providers
+    FileData fileData(prop, uuid);
+
+    for (int32_t i = mProviders.Length() - 1; i >= 0; i--) {
+        if (!FindProviderFile(mProviders[i], &fileData)) {
+            break;
+        }
+    }
+    if (fileData.data)
+    {
+        if (fileData.persistent)
+        {
+            Set(prop, static_cast<nsIFile*>(fileData.data));
+        }
+        nsresult rv = (fileData.data)->QueryInterface(uuid, result);
+        NS_RELEASE(fileData.data);  // addref occurs in FindProviderFile()
+        return rv;
+    }
+
+    FindProviderFile(static_cast<nsIDirectoryServiceProvider*>(this), &fileData);
+    if (fileData.data)
+    {
+        if (fileData.persistent)
+        {
+            Set(prop, static_cast<nsIFile*>(fileData.data));
+        }
+        nsresult rv = (fileData.data)->QueryInterface(uuid, result);
+        NS_RELEASE(fileData.data);  // addref occurs in FindProviderFile()
+        return rv;
+    }
+
+    return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsDirectoryService::Set(const char* prop, nsISupports* value)
+{
+    if (NS_WARN_IF(!prop))
+        return NS_ERROR_INVALID_ARG;
+
+    nsDependentCString key(prop);
+    if (mHashtable.Get(key, nullptr) || !value) {
+        return NS_ERROR_FAILURE;
+    }
+
+    nsCOMPtr<nsIFile> ourFile = do_QueryInterface(value);
+    if (ourFile) {
+      nsCOMPtr<nsIFile> cloneFile;
+      ourFile->Clone (getter_AddRefs (cloneFile));
+      mHashtable.Put(key, cloneFile);
+
+      return NS_OK;
+    }
+
+    return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsDirectoryService::Has(const char *prop, bool *_retval)
+{
+    if (NS_WARN_IF(!prop))
+        return NS_ERROR_INVALID_ARG;
+
+    *_retval = false;
+    nsCOMPtr<nsIFile> value;
+    nsresult rv = Get(prop, NS_GET_IID(nsIFile), getter_AddRefs(value));
+    if (NS_FAILED(rv))
+        return NS_OK;
+    
+    if (value)
+    {
+        *_retval = true;
+    }
+    
+    return rv;
+}
+
+NS_IMETHODIMP
+nsDirectoryService::RegisterProvider(nsIDirectoryServiceProvider *prov)
+{
+    if (!prov)
+        return NS_ERROR_FAILURE;
+
+    mProviders.AppendElement(prov);
+    return NS_OK;
+}
+
+void
+nsDirectoryService::RegisterCategoryProviders()
+{
+    nsCOMPtr<nsICategoryManager> catman
+        (do_GetService(NS_CATEGORYMANAGER_CONTRACTID));
+    if (!catman)
+        return;
+
+    nsCOMPtr<nsISimpleEnumerator> entries;
+    catman->EnumerateCategory(XPCOM_DIRECTORY_PROVIDER_CATEGORY,
+                              getter_AddRefs(entries));
+
+    nsCOMPtr<nsIUTF8StringEnumerator> strings(do_QueryInterface(entries));
+    if (!strings)
+        return;
+
+    bool more;
+    while (NS_SUCCEEDED(strings->HasMore(&more)) && more) {
+        nsAutoCString entry;
+        strings->GetNext(entry);
+
+        nsXPIDLCString contractID;
+        catman->GetCategoryEntry(XPCOM_DIRECTORY_PROVIDER_CATEGORY, entry.get(), getter_Copies(contractID));
+
+        if (contractID) {
+            nsCOMPtr<nsIDirectoryServiceProvider> provider = do_GetService(contractID.get());
+            if (provider)
+                RegisterProvider(provider);
+        }
+    }
+}
+
+NS_IMETHODIMP
+nsDirectoryService::UnregisterProvider(nsIDirectoryServiceProvider *prov)
+{
+    if (!prov)
+        return NS_ERROR_FAILURE;
+
+    mProviders.RemoveElement(prov);
+    return NS_OK;
+}
+
+// DO NOT ADD ANY LOCATIONS TO THIS FUNCTION UNTIL YOU TALK TO: dougt@netscape.com.
+// This is meant to be a place of xpcom or system specific file locations, not
+// application specific locations.  If you need the later, register a callback for
+// your application.  
+
+NS_IMETHODIMP
+nsDirectoryService::GetFile(const char *prop, bool *persistent, nsIFile **_retval)
+{
+    nsCOMPtr<nsIFile> localFile;
+    nsresult rv = NS_ERROR_FAILURE;
+
+    *_retval = nullptr;
+    *persistent = true;
+
+    nsCOMPtr<nsIAtom> inAtom = do_GetAtom(prop);
+
+    // check to see if it is one of our defaults
+        
+    if (inAtom == nsDirectoryService::sCurrentProcess || 
+        inAtom == nsDirectoryService::sOS_CurrentProcessDirectory )
+    {
+        rv = GetCurrentProcessDirectory(getter_AddRefs(localFile));
+    }
+    
+    // Unless otherwise set, the core pieces of the GRE exist
+    // in the current process directory.
+    else if (inAtom == nsDirectoryService::sGRE_Directory)
+    {
+        rv = GetCurrentProcessDirectory(getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sOS_DriveDirectory)
+    {
+        rv = GetSpecialSystemDirectory(OS_DriveDirectory, getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sOS_TemporaryDirectory)
+    {
+        rv = GetSpecialSystemDirectory(OS_TemporaryDirectory, getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sOS_CurrentProcessDirectory)
+    {
+        rv = GetSpecialSystemDirectory(OS_CurrentProcessDirectory, getter_AddRefs(localFile)); 
+    }
+    else if (inAtom == nsDirectoryService::sOS_CurrentWorkingDirectory)
+    {
+        rv = GetSpecialSystemDirectory(OS_CurrentWorkingDirectory, getter_AddRefs(localFile)); 
+    }
+       
+#if defined(MOZ_WIDGET_COCOA)
+    else if (inAtom == nsDirectoryService::sDirectory)
+    {
+        rv = GetOSXFolderType(kClassicDomain, kSystemFolderType, getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sTrashDirectory)
+    {
+        rv = GetOSXFolderType(kClassicDomain, kTrashFolderType, getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sStartupDirectory)
+    {
+        rv = GetOSXFolderType(kClassicDomain, kStartupFolderType, getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sShutdownDirectory)
+    {
+        rv = GetOSXFolderType(kClassicDomain, kShutdownFolderType, getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sAppleMenuDirectory)
+    {
+        rv = GetOSXFolderType(kClassicDomain, kAppleMenuFolderType, getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sControlPanelDirectory)
+    {
+        rv = GetOSXFolderType(kClassicDomain, kControlPanelFolderType, getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sExtensionDirectory)
+    {
+        rv = GetOSXFolderType(kClassicDomain, kExtensionFolderType, getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sFontsDirectory)
+    {
+        rv = GetOSXFolderType(kClassicDomain, kFontsFolderType, getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sPreferencesDirectory)
+    {
+        rv = GetOSXFolderType(kClassicDomain, kPreferencesFolderType, getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sDocumentsDirectory)
+    {
+        rv = GetOSXFolderType(kClassicDomain, kDocumentsFolderType, getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sInternetSearchDirectory)
+    {
+        rv = GetOSXFolderType(kClassicDomain, kInternetSearchSitesFolderType, getter_AddRefs(localFile));
+    }   
+    else if (inAtom == nsDirectoryService::sUserLibDirectory)
+    {
+        rv = GetOSXFolderType(kUserDomain, kDomainLibraryFolderType, getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sOS_HomeDirectory)
+    {
+        rv = GetOSXFolderType(kUserDomain, kDomainTopLevelFolderType, getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sDefaultDownloadDirectory)
+    {
+        // 10.5 and later, we can use kDownloadsFolderType which is defined in
+        // Folders.h as "down".  However, in order to support 10.4 still, we
+        // cannot use the named constant.  We'll use it's value, and if it
+        // fails, fall back to the desktop.
+#ifndef kDownloadsFolderType
+#define kDownloadsFolderType 'down'
+#endif
+
+        rv = GetOSXFolderType(kUserDomain, kDownloadsFolderType,
+                              getter_AddRefs(localFile));
+        if (NS_FAILED(rv)) {
+            rv = GetOSXFolderType(kUserDomain, kDesktopFolderType,
+                                  getter_AddRefs(localFile));
+        }
+    }
+    else if (inAtom == nsDirectoryService::sUserDesktopDirectory ||
+             inAtom == nsDirectoryService::sOS_DesktopDirectory)
+    {
+        rv = GetOSXFolderType(kUserDomain, kDesktopFolderType, getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sLocalDesktopDirectory)
+    {
+        rv = GetOSXFolderType(kLocalDomain, kDesktopFolderType, getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sUserApplicationsDirectory)
+    {
+        rv = GetOSXFolderType(kUserDomain, kApplicationsFolderType, getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sLocalApplicationsDirectory)
+    {
+        rv = GetOSXFolderType(kLocalDomain, kApplicationsFolderType, getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sUserDocumentsDirectory)
+    {
+        rv = GetOSXFolderType(kUserDomain, kDocumentsFolderType, getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sLocalDocumentsDirectory)
+    {
+        rv = GetOSXFolderType(kLocalDomain, kDocumentsFolderType, getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sUserInternetPlugInDirectory)
+    {
+        rv = GetOSXFolderType(kUserDomain, kInternetPlugInFolderType, getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sLocalInternetPlugInDirectory)
+    {
+        rv = GetOSXFolderType(kLocalDomain, kInternetPlugInFolderType, getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sUserFrameworksDirectory)
+    {
+        rv = GetOSXFolderType(kUserDomain, kFrameworksFolderType, getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sLocalFrameworksDirectory)
+    {
+        rv = GetOSXFolderType(kLocalDomain, kFrameworksFolderType, getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sUserPreferencesDirectory)
+    {
+        rv = GetOSXFolderType(kUserDomain, kPreferencesFolderType, getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sLocalPreferencesDirectory)
+    {
+        rv = GetOSXFolderType(kLocalDomain, kPreferencesFolderType, getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sPictureDocumentsDirectory)
+    {
+        rv = GetOSXFolderType(kUserDomain, kPictureDocumentsFolderType, getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sMovieDocumentsDirectory)
+    {
+        rv = GetOSXFolderType(kUserDomain, kMovieDocumentsFolderType, getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sMusicDocumentsDirectory)
+    {
+        rv = GetOSXFolderType(kUserDomain, kMusicDocumentsFolderType, getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sInternetSitesDirectory)
+    {
+        rv = GetOSXFolderType(kUserDomain, kInternetSitesFolderType, getter_AddRefs(localFile));
+    }
+#elif defined (XP_WIN)
+    else if (inAtom == nsDirectoryService::sSystemDirectory)
+    {
+        rv = GetSpecialSystemDirectory(Win_SystemDirectory, getter_AddRefs(localFile)); 
+    }
+    else if (inAtom == nsDirectoryService::sWindowsDirectory)
+    {
+        rv = GetSpecialSystemDirectory(Win_WindowsDirectory, getter_AddRefs(localFile)); 
+    }
+    else if (inAtom == nsDirectoryService::sWindowsProgramFiles)
+    {
+        rv = GetSpecialSystemDirectory(Win_ProgramFiles, getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sOS_HomeDirectory)
+    {
+        rv = GetSpecialSystemDirectory(Win_HomeDirectory, getter_AddRefs(localFile)); 
+    }
+    else if (inAtom == nsDirectoryService::sDesktop)
+    {
+        rv = GetSpecialSystemDirectory(Win_Desktop, getter_AddRefs(localFile)); 
+    }
+    else if (inAtom == nsDirectoryService::sPrograms)
+    {
+        rv = GetSpecialSystemDirectory(Win_Programs, getter_AddRefs(localFile)); 
+    }
+    else if (inAtom == nsDirectoryService::sControls)
+    {
+        rv = GetSpecialSystemDirectory(Win_Controls, getter_AddRefs(localFile)); 
+    }
+    else if (inAtom == nsDirectoryService::sPrinters)
+    {
+        rv = GetSpecialSystemDirectory(Win_Printers, getter_AddRefs(localFile)); 
+    }
+    else if (inAtom == nsDirectoryService::sPersonal)
+    {
+        rv = GetSpecialSystemDirectory(Win_Personal, getter_AddRefs(localFile)); 
+    }
+    else if (inAtom == nsDirectoryService::sFavorites)
+    {
+        rv = GetSpecialSystemDirectory(Win_Favorites, getter_AddRefs(localFile)); 
+    }
+    else if (inAtom == nsDirectoryService::sStartup)
+    {
+        rv = GetSpecialSystemDirectory(Win_Startup, getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sRecent)
+    {
+        rv = GetSpecialSystemDirectory(Win_Recent, getter_AddRefs(localFile)); 
+    }
+    else if (inAtom == nsDirectoryService::sSendto)
+    {
+        rv = GetSpecialSystemDirectory(Win_Sendto, getter_AddRefs(localFile)); 
+    }
+    else if (inAtom == nsDirectoryService::sBitbucket)
+    {
+        rv = GetSpecialSystemDirectory(Win_Bitbucket, getter_AddRefs(localFile)); 
+    }
+    else if (inAtom == nsDirectoryService::sStartmenu)
+    {
+        rv = GetSpecialSystemDirectory(Win_Startmenu, getter_AddRefs(localFile)); 
+    }
+    else if (inAtom == nsDirectoryService::sDesktopdirectory ||
+             inAtom == nsDirectoryService::sOS_DesktopDirectory)
+    {
+        rv = GetSpecialSystemDirectory(Win_Desktopdirectory, getter_AddRefs(localFile)); 
+    }
+    else if (inAtom == nsDirectoryService::sDrives)
+    {
+        rv = GetSpecialSystemDirectory(Win_Drives, getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sNetwork)
+    {
+        rv = GetSpecialSystemDirectory(Win_Network, getter_AddRefs(localFile)); 
+    }
+    else if (inAtom == nsDirectoryService::sNethood)
+    {
+        rv = GetSpecialSystemDirectory(Win_Nethood, getter_AddRefs(localFile)); 
+    }
+    else if (inAtom == nsDirectoryService::sFonts)
+    {
+        rv = GetSpecialSystemDirectory(Win_Fonts, getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sTemplates)
+    {
+        rv = GetSpecialSystemDirectory(Win_Templates, getter_AddRefs(localFile)); 
+    }
+    else if (inAtom == nsDirectoryService::sCommon_Startmenu)
+    {
+        rv = GetSpecialSystemDirectory(Win_Common_Startmenu, getter_AddRefs(localFile)); 
+    }
+    else if (inAtom == nsDirectoryService::sCommon_Programs)
+    {
+        rv = GetSpecialSystemDirectory(Win_Common_Programs, getter_AddRefs(localFile)); 
+    }
+    else if (inAtom == nsDirectoryService::sCommon_Startup)
+    {
+        rv = GetSpecialSystemDirectory(Win_Common_Startup, getter_AddRefs(localFile)); 
+    }
+    else if (inAtom == nsDirectoryService::sCommon_Desktopdirectory)
+    {
+        rv = GetSpecialSystemDirectory(Win_Common_Desktopdirectory, getter_AddRefs(localFile)); 
+    }
+    else if (inAtom == nsDirectoryService::sCommon_AppData)
+    {
+        rv = GetSpecialSystemDirectory(Win_Common_AppData, getter_AddRefs(localFile)); 
+    }
+    else if (inAtom == nsDirectoryService::sAppdata)
+    {
+        rv = GetSpecialSystemDirectory(Win_Appdata, getter_AddRefs(localFile)); 
+    }
+    else if (inAtom == nsDirectoryService::sLocalAppdata)
+    {
+        rv = GetSpecialSystemDirectory(Win_LocalAppdata, getter_AddRefs(localFile)); 
+    }
+    else if (inAtom == nsDirectoryService::sPrinthood)
+    {
+        rv = GetSpecialSystemDirectory(Win_Printhood, getter_AddRefs(localFile)); 
+    }
+    else if (inAtom == nsDirectoryService::sWinCookiesDirectory)
+    {
+        rv = GetSpecialSystemDirectory(Win_Cookies, getter_AddRefs(localFile)); 
+    }
+    else if (inAtom == nsDirectoryService::sDefaultDownloadDirectory)
+    {
+        rv = GetSpecialSystemDirectory(Win_Downloads, getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sDocs)
+    {
+        rv = GetSpecialSystemDirectory(Win_Documents, getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sPictures)
+    {
+        rv = GetSpecialSystemDirectory(Win_Pictures, getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sMusic)
+    {
+        rv = GetSpecialSystemDirectory(Win_Music, getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sVideos)
+    {
+        rv = GetSpecialSystemDirectory(Win_Videos, getter_AddRefs(localFile));
+    }
+#elif defined (XP_UNIX)
+
+    else if (inAtom == nsDirectoryService::sLocalDirectory)
+    {
+        rv = GetSpecialSystemDirectory(Unix_LocalDirectory, getter_AddRefs(localFile)); 
+    }
+    else if (inAtom == nsDirectoryService::sLibDirectory)
+    {
+        rv = GetSpecialSystemDirectory(Unix_LibDirectory, getter_AddRefs(localFile));
+    }
+    else if (inAtom == nsDirectoryService::sOS_HomeDirectory)
+    {
+        rv = GetSpecialSystemDirectory(Unix_HomeDirectory, getter_AddRefs(localFile)); 
+    }
+    else if (inAtom == nsDirectoryService::sXDGDesktop ||
+             inAtom == nsDirectoryService::sOS_DesktopDirectory)
+    {
+        rv = GetSpecialSystemDirectory(Unix_XDG_Desktop, getter_AddRefs(localFile));
+        *persistent = false;
+    }
+    else if (inAtom == nsDirectoryService::sXDGDocuments)
+    {
+        rv = GetSpecialSystemDirectory(Unix_XDG_Documents, getter_AddRefs(localFile));
+        *persistent = false;
+    }
+    else if (inAtom == nsDirectoryService::sXDGDownload ||
+             inAtom == nsDirectoryService::sDefaultDownloadDirectory)
+    {
+        rv = GetSpecialSystemDirectory(Unix_XDG_Download, getter_AddRefs(localFile));
+        *persistent = false;
+    }
+    else if (inAtom == nsDirectoryService::sXDGMusic)
+    {
+        rv = GetSpecialSystemDirectory(Unix_XDG_Music, getter_AddRefs(localFile));
+        *persistent = false;
+    }
+    else if (inAtom == nsDirectoryService::sXDGPictures)
+    {
+        rv = GetSpecialSystemDirectory(Unix_XDG_Pictures, getter_AddRefs(localFile));
+        *persistent = false;
+    }
+    else if (inAtom == nsDirectoryService::sXDGPublicShare)
+    {
+        rv = GetSpecialSystemDirectory(Unix_XDG_PublicShare, getter_AddRefs(localFile));
+        *persistent = false;
+    }
+    else if (inAtom == nsDirectoryService::sXDGTemplates)
+    {
+        rv = GetSpecialSystemDirectory(Unix_XDG_Templates, getter_AddRefs(localFile));
+        *persistent = false;
+    }
+    else if (inAtom == nsDirectoryService::sXDGVideos)
+    {
+        rv = GetSpecialSystemDirectory(Unix_XDG_Videos, getter_AddRefs(localFile));
+        *persistent = false;
+    }
+#endif
+
+    if (NS_FAILED(rv))
+        return rv;
+
+    if (!localFile)
+        return NS_ERROR_FAILURE;
+
+    localFile.forget(_retval);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDirectoryService::GetFiles(const char *prop, nsISimpleEnumerator **_retval)
+{
+    if (NS_WARN_IF(!_retval))
+        return NS_ERROR_INVALID_ARG;
+    *_retval = nullptr;
+        
+    return NS_ERROR_FAILURE;
+}