The Tor Browser: xpcom/io/nsDirectoryService.cpp@97036ab72558 (annotated)

xpcom/io/nsDirectoryService.cpp@97036ab72558 (annotated)

xpcom/io/nsDirectoryService.cpp

Tue, 06 Jan 2015 21:39:09 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 06 Jan 2015 21:39:09 +0100
branch: TOR_BUG_9701
changeset 8: 97036ab72558
permissions: -rw-r--r--

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /* -*- 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;
 }

The Tor Browser / annotate

xpcom/io/nsDirectoryService.cpp@97036ab72558 (annotated)

xpcom/io/nsDirectoryService.cpp