xpcom/io/nsDirectoryService.cpp

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is mozilla.org code.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Netscape Communications Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 1998
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *   IBM Corp.
  24  *   Fredrik Holmqvist <thesuckiestemail@yahoo.se>
  25  *
  26  * Alternatively, the contents of this file may be used under the terms of
  27  * either of the GNU General Public License Version 2 or later (the "GPL"),
  28  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  29  * in which case the provisions of the GPL or the LGPL are applicable instead
  30  * of those above. If you wish to allow use of your version of this file only
  31  * under the terms of either the GPL or the LGPL, and not to allow others to
  32  * use your version of this file under the terms of the MPL, indicate your
  33  * decision by deleting the provisions above and replace them with the notice
  34  * and other provisions required by the GPL or the LGPL. If you do not delete
  35  * the provisions above, a recipient may use your version of this file under
  36  * the terms of any one of the MPL, the GPL or the LGPL.
  37  *
  38  * ***** END LICENSE BLOCK ***** */
  39
  40 #include "nsCOMPtr.h"
  41 #include "nsAutoPtr.h"
  42 #include "nsDirectoryService.h"
  43 #include "nsDirectoryServiceDefs.h"
  44 #include "nsLocalFile.h"
  45 #include "nsDebug.h"
  46 #include "nsStaticAtom.h"
  47 #include "nsEnumeratorUtils.h"
  48
  49 #include "nsICategoryManager.h"
  50 #include "nsISimpleEnumerator.h"
  51 #include "nsIStringEnumerator.h"
  52
  53 #if defined(XP_WIN)
  54 #include <windows.h>
  55 #include <shlobj.h>
  56 #include <stdlib.h>
  57 #include <stdio.h>
  58 #elif defined(XP_UNIX)
  59 #include <unistd.h>
  60 #include <stdlib.h>
  61 #include <sys/param.h>
  62 #include "prenv.h"
  63 #ifdef XP_MACOSX
  64 #include <CoreServices/CoreServices.h>
  65 #include <Folders.h>
  66 #include <Files.h>
  67 #include <Memory.h>
  68 #include <Processes.h>
  69 #include <Gestalt.h>
  70 #include <CFURL.h>
  71 #include <InternetConfig.h>
  72 #endif
  73 #elif defined(XP_OS2)
  74 #define MAX_PATH _MAX_PATH
  75 #elif defined(XP_BEOS)
  76 #include <FindDirectory.h>
  77 #include <Path.h>
  78 #include <unistd.h>
  79 #include <stdlib.h>
  80 #include <sys/param.h>
  81 #include <OS.h>
  82 #include <image.h>
  83 #include "prenv.h"
  84 #endif
  85
  86 #include "SpecialSystemDirectory.h"
  87 #include "nsAppFileLocationProvider.h"
  88
  89 #define COMPONENT_REGISTRY_NAME NS_LITERAL_CSTRING("compreg.dat")
  90 #define COMPONENT_DIRECTORY     NS_LITERAL_CSTRING("components")
  91
  92 #define XPTI_REGISTRY_NAME      NS_LITERAL_CSTRING("xpti.dat")
  93
  94 // define home directory
  95 // For Windows platform, We are choosing Appdata folder as HOME
  96 #if defined (XP_WIN)
  97 #define HOME_DIR NS_WIN_APPDATA_DIR
  98 #elif defined (XP_MACOSX)
  99 #define HOME_DIR NS_OSX_HOME_DIR
 100 #elif defined (XP_UNIX)
 101 #define HOME_DIR NS_UNIX_HOME_DIR
 102 #elif defined (XP_OS2)
 103 #define HOME_DIR NS_OS2_HOME_DIR
 104 #elif defined (XP_BEOS)
 105 #define HOME_DIR NS_BEOS_HOME_DIR
 106 #endif
 107
 108 //----------------------------------------------------------------------------------------
 109 nsresult
 110 nsDirectoryService::GetCurrentProcessDirectory(nsILocalFile** aFile)
 111 //----------------------------------------------------------------------------------------
 112 {
 113     NS_ENSURE_ARG_POINTER(aFile);
 114     *aFile = nsnull;
 115
 116    //  Set the component registry location:
 117     if (!gService)
 118         return NS_ERROR_FAILURE;
 119
 120     nsresult rv;
 121
 122     nsCOMPtr<nsIProperties> dirService;
 123     rv = nsDirectoryService::Create(nsnull,
 124                                     NS_GET_IID(nsIProperties),
 125                                     getter_AddRefs(dirService));  // needs to be around for life of product
 126
 127     if (dirService)
 128     {
 129       nsCOMPtr <nsILocalFile> aLocalFile;
 130       dirService->Get(NS_XPCOM_INIT_CURRENT_PROCESS_DIR, NS_GET_IID(nsILocalFile), getter_AddRefs(aLocalFile));
 131       if (aLocalFile)
 132       {
 133         *aFile = aLocalFile;
 134         NS_ADDREF(*aFile);
 135         return NS_OK;
 136       }
 137     }
 138
 139     nsLocalFile* localFile = new nsLocalFile;
 140
 141     if (localFile == nsnull)
 142         return NS_ERROR_OUT_OF_MEMORY;
 143     NS_ADDREF(localFile);
 144
 145
 146
 147 #ifdef XP_WIN
 148     PRUnichar buf[MAX_PATH];
 149     if ( ::GetModuleFileNameW(0, buf, sizeof(buf)) )
 150     {
 151         // chop off the executable name by finding the rightmost backslash
 152         PRUnichar* lastSlash = wcsrchr(buf, L'\\');
 153         if (lastSlash)
 154             *(lastSlash + 1) = L'\0';
 155
 156         localFile->InitWithPath(nsDependentString(buf));
 157         *aFile = localFile;
 158         return NS_OK;
 159     }
 160
 161 #elif defined(XP_MACOSX)
 162     // Works even if we're not bundled.
 163     CFBundleRef appBundle = CFBundleGetMainBundle();
 164     if (appBundle != nsnull)
 165     {
 166         CFURLRef bundleURL = CFBundleCopyExecutableURL(appBundle);
 167         if (bundleURL != nsnull)
 168         {
 169             CFURLRef parentURL = CFURLCreateCopyDeletingLastPathComponent(kCFAllocatorDefault, bundleURL);
 170             if (parentURL)
 171             {
 172                 // Pass PR_TRUE for the "resolveAgainstBase" arg to CFURLGetFileSystemRepresentation.
 173                 // This will resolve the relative portion of the CFURL against it base, giving a full
 174                 // path, which CFURLCopyFileSystemPath doesn't do.
 175                 char buffer[PATH_MAX];
 176                 if (CFURLGetFileSystemRepresentation(parentURL, PR_TRUE, (UInt8 *)buffer, sizeof(buffer)))
 177                 {
 178 #ifdef DEBUG_conrad
 179                     printf("nsDirectoryService - CurrentProcessDir is: %s\n", buffer);
 180 #endif
 181                     rv = localFile->InitWithNativePath(nsDependentCString(buffer));
 182                     if (NS_SUCCEEDED(rv))
 183                         *aFile = localFile;
 184                 }
 185                 CFRelease(parentURL);
 186             }
 187             CFRelease(bundleURL);
 188         }
 189     }
 190
 191     NS_ASSERTION(*aFile, "nsDirectoryService - Could not determine CurrentProcessDir.\n");
 192     if (*aFile)
 193         return NS_OK;
 194
 195 #elif defined(XP_UNIX)
 196
 197     // In the absence of a good way to get the executable directory let
 198     // us try this for unix:
 199     //    - if MOZILLA_FIVE_HOME is defined, that is it
 200     //    - else give the current directory
 201     char buf[MAXPATHLEN];
 202
 203     // The MOZ_DEFAULT_MOZILLA_FIVE_HOME variable can be set at configure time with
 204     // a --with-default-mozilla-five-home=foo autoconf flag.
 205     //
 206     // The idea here is to allow for builds that have a default MOZILLA_FIVE_HOME
 207     // regardless of the environment.  This makes it easier to write apps that
 208     // embed mozilla without having to worry about setting up the environment
 209     //
 210     // We do this by putenv()ing the default value into the environment.  Note that
 211     // we only do this if it is not already set.
 212 #ifdef MOZ_DEFAULT_MOZILLA_FIVE_HOME
 213     const char *home = PR_GetEnv("MOZILLA_FIVE_HOME");
 214     if (!home || !*home)
 215     {
 216         putenv("MOZILLA_FIVE_HOME=" MOZ_DEFAULT_MOZILLA_FIVE_HOME);
 217     }
 218 #endif
 219
 220     char *moz5 = PR_GetEnv("MOZILLA_FIVE_HOME");
 221     if (moz5 && *moz5)
 222     {
 223         if (realpath(moz5, buf)) {
 224             localFile->InitWithNativePath(nsDependentCString(buf));
 225             *aFile = localFile;
 226             return NS_OK;
 227         }
 228     }
 229 #if defined(DEBUG)
 230     static PRBool firstWarning = PR_TRUE;
 231
 232     if((!moz5 || !*moz5) && firstWarning) {
 233         // Warn that MOZILLA_FIVE_HOME not set, once.
 234         printf("Warning: MOZILLA_FIVE_HOME not set.\n");
 235         firstWarning = PR_FALSE;
 236     }
 237 #endif /* DEBUG */
 238
 239     // Fall back to current directory.
 240     if (getcwd(buf, sizeof(buf)))
 241     {
 242         localFile->InitWithNativePath(nsDependentCString(buf));
 243         *aFile = localFile;
 244         return NS_OK;
 245     }
 246
 247 #elif defined(XP_OS2)
 248     PPIB ppib;
 249     PTIB ptib;
 250     char buffer[CCHMAXPATH];
 251     DosGetInfoBlocks( &ptib, &ppib);
 252     DosQueryModuleName( ppib->pib_hmte, CCHMAXPATH, buffer);
 253     *strrchr( buffer, '\\') = '\0'; // XXX DBCS misery
 254     localFile->InitWithNativePath(nsDependentCString(buffer));
 255     *aFile = localFile;
 256     return NS_OK;
 257
 258 #elif defined(XP_BEOS)
 259     char buf[MAXPATHLEN];
 260     int32 cookie = 0;
 261     image_info info;
 262     char *p;
 263     *buf = 0;
 264     if(get_next_image_info(0, &cookie, &info) == B_OK)
 265     {
 266         strcpy(buf, info.name);
 267         if((p = strrchr(buf, '/')) != 0)
 268         {
 269             if( (p-2 >= buf) && *(p-2)=='/' && *(p-1)=='.')
 270                 p -=2;
 271             *p = 0;
 272             localFile->InitWithNativePath(nsDependentCString(buf));
 273             *aFile = localFile;
 274             return NS_OK;
 275         }
 276     }
 277 #endif
 278
 279     NS_RELEASE(localFile);
 280
 281     NS_ERROR("unable to get current process directory");
 282     return NS_ERROR_FAILURE;
 283 } // GetCurrentProcessDirectory()
 284
 285
 286 nsIAtom*  nsDirectoryService::sCurrentProcess = nsnull;
 287 nsIAtom*  nsDirectoryService::sComponentRegistry = nsnull;
 288 nsIAtom*  nsDirectoryService::sXPTIRegistry = nsnull;
 289 nsIAtom*  nsDirectoryService::sComponentDirectory = nsnull;
 290 nsIAtom*  nsDirectoryService::sGRE_Directory = nsnull;
 291 nsIAtom*  nsDirectoryService::sGRE_ComponentDirectory = nsnull;
 292 nsIAtom*  nsDirectoryService::sOS_DriveDirectory = nsnull;
 293 nsIAtom*  nsDirectoryService::sOS_TemporaryDirectory = nsnull;
 294 nsIAtom*  nsDirectoryService::sOS_CurrentProcessDirectory = nsnull;
 295 nsIAtom*  nsDirectoryService::sOS_CurrentWorkingDirectory = nsnull;
 296 nsIAtom*  nsDirectoryService::sOS_DesktopDirectory = nsnull;
 297 nsIAtom*  nsDirectoryService::sOS_HomeDirectory = nsnull;
 298 #if defined (XP_MACOSX)
 299 nsIAtom*  nsDirectoryService::sDirectory = nsnull;
 300 nsIAtom*  nsDirectoryService::sTrashDirectory = nsnull;
 301 nsIAtom*  nsDirectoryService::sStartupDirectory = nsnull;
 302 nsIAtom*  nsDirectoryService::sShutdownDirectory = nsnull;
 303 nsIAtom*  nsDirectoryService::sAppleMenuDirectory = nsnull;
 304 nsIAtom*  nsDirectoryService::sControlPanelDirectory = nsnull;
 305 nsIAtom*  nsDirectoryService::sExtensionDirectory = nsnull;
 306 nsIAtom*  nsDirectoryService::sFontsDirectory = nsnull;
 307 nsIAtom*  nsDirectoryService::sPreferencesDirectory = nsnull;
 308 nsIAtom*  nsDirectoryService::sDocumentsDirectory = nsnull;
 309 nsIAtom*  nsDirectoryService::sInternetSearchDirectory = nsnull;
 310 nsIAtom*  nsDirectoryService::sUserLibDirectory = nsnull;
 311 nsIAtom*  nsDirectoryService::sDefaultDownloadDirectory = nsnull;
 312 nsIAtom*  nsDirectoryService::sUserDesktopDirectory = nsnull;
 313 nsIAtom*  nsDirectoryService::sLocalDesktopDirectory = nsnull;
 314 nsIAtom*  nsDirectoryService::sUserApplicationsDirectory = nsnull;
 315 nsIAtom*  nsDirectoryService::sLocalApplicationsDirectory = nsnull;
 316 nsIAtom*  nsDirectoryService::sUserDocumentsDirectory = nsnull;
 317 nsIAtom*  nsDirectoryService::sLocalDocumentsDirectory = nsnull;
 318 nsIAtom*  nsDirectoryService::sUserInternetPlugInDirectory = nsnull;
 319 nsIAtom*  nsDirectoryService::sLocalInternetPlugInDirectory = nsnull;
 320 nsIAtom*  nsDirectoryService::sUserFrameworksDirectory = nsnull;
 321 nsIAtom*  nsDirectoryService::sLocalFrameworksDirectory = nsnull;
 322 nsIAtom*  nsDirectoryService::sUserPreferencesDirectory = nsnull;
 323 nsIAtom*  nsDirectoryService::sLocalPreferencesDirectory = nsnull;
 324 nsIAtom*  nsDirectoryService::sPictureDocumentsDirectory = nsnull;
 325 nsIAtom*  nsDirectoryService::sMovieDocumentsDirectory = nsnull;
 326 nsIAtom*  nsDirectoryService::sMusicDocumentsDirectory = nsnull;
 327 nsIAtom*  nsDirectoryService::sInternetSitesDirectory = nsnull;
 328 #elif defined (XP_WIN)
 329 nsIAtom*  nsDirectoryService::sSystemDirectory = nsnull;
 330 nsIAtom*  nsDirectoryService::sWindowsDirectory = nsnull;
 331 nsIAtom*  nsDirectoryService::sWindowsProgramFiles = nsnull;
 332 nsIAtom*  nsDirectoryService::sDesktop = nsnull;
 333 nsIAtom*  nsDirectoryService::sPrograms = nsnull;
 334 nsIAtom*  nsDirectoryService::sControls = nsnull;
 335 nsIAtom*  nsDirectoryService::sPrinters = nsnull;
 336 nsIAtom*  nsDirectoryService::sPersonal = nsnull;
 337 nsIAtom*  nsDirectoryService::sFavorites = nsnull;
 338 nsIAtom*  nsDirectoryService::sStartup = nsnull;
 339 nsIAtom*  nsDirectoryService::sRecent = nsnull;
 340 nsIAtom*  nsDirectoryService::sSendto = nsnull;
 341 nsIAtom*  nsDirectoryService::sBitbucket = nsnull;
 342 nsIAtom*  nsDirectoryService::sStartmenu = nsnull;
 343 nsIAtom*  nsDirectoryService::sDesktopdirectory = nsnull;
 344 nsIAtom*  nsDirectoryService::sDrives = nsnull;
 345 nsIAtom*  nsDirectoryService::sNetwork = nsnull;
 346 nsIAtom*  nsDirectoryService::sNethood = nsnull;
 347 nsIAtom*  nsDirectoryService::sFonts = nsnull;
 348 nsIAtom*  nsDirectoryService::sTemplates = nsnull;
 349 nsIAtom*  nsDirectoryService::sCommon_Startmenu = nsnull;
 350 nsIAtom*  nsDirectoryService::sCommon_Programs = nsnull;
 351 nsIAtom*  nsDirectoryService::sCommon_Startup = nsnull;
 352 nsIAtom*  nsDirectoryService::sCommon_Desktopdirectory = nsnull;
 353 nsIAtom*  nsDirectoryService::sAppdata = nsnull;
 354 nsIAtom*  nsDirectoryService::sLocalAppdata = nsnull;
 355 nsIAtom*  nsDirectoryService::sPrinthood = nsnull;
 356 nsIAtom*  nsDirectoryService::sWinCookiesDirectory = nsnull;
 357 nsIAtom*  nsDirectoryService::sDefaultDownloadDirectory = nsnull;
 358 #elif defined (XP_UNIX)
 359 nsIAtom*  nsDirectoryService::sLocalDirectory = nsnull;
 360 nsIAtom*  nsDirectoryService::sLibDirectory = nsnull;
 361 nsIAtom*  nsDirectoryService::sDefaultDownloadDirectory = nsnull;
 362 nsIAtom*  nsDirectoryService::sXDGDesktop = nsnull;
 363 nsIAtom*  nsDirectoryService::sXDGDocuments = nsnull;
 364 nsIAtom*  nsDirectoryService::sXDGDownload = nsnull;
 365 nsIAtom*  nsDirectoryService::sXDGMusic = nsnull;
 366 nsIAtom*  nsDirectoryService::sXDGPictures = nsnull;
 367 nsIAtom*  nsDirectoryService::sXDGPublicShare = nsnull;
 368 nsIAtom*  nsDirectoryService::sXDGTemplates = nsnull;
 369 nsIAtom*  nsDirectoryService::sXDGVideos = nsnull;
 370 #elif defined (XP_OS2)
 371 nsIAtom*  nsDirectoryService::sSystemDirectory = nsnull;
 372 nsIAtom*  nsDirectoryService::sOS2Directory = nsnull;
 373 #elif defined (XP_BEOS)
 374 nsIAtom*  nsDirectoryService::sSettingsDirectory = nsnull;
 375 nsIAtom*  nsDirectoryService::sSystemDirectory = nsnull;
 376 #endif
 377
 378
 379 nsDirectoryService* nsDirectoryService::gService = nsnull;
 380
 381 nsDirectoryService::nsDirectoryService() :
 382     mHashtable(256, PR_TRUE)
 383 {
 384 }
 385
 386 NS_METHOD
 387 nsDirectoryService::Create(nsISupports *outer, REFNSIID aIID, void **aResult)
 388 {
 389     NS_ENSURE_ARG_POINTER(aResult);
 390     NS_ENSURE_NO_AGGREGATION(outer);
 391
 392     if (!gService)
 393     {
 394         return NS_ERROR_NOT_INITIALIZED;
 395     }
 396
 397     return gService->QueryInterface(aIID, aResult);
 398 }
 399
 400 static const nsStaticAtom directory_atoms[] = {
 401     { NS_XPCOM_CURRENT_PROCESS_DIR,     &nsDirectoryService::sCurrentProcess },
 402     { NS_XPCOM_COMPONENT_REGISTRY_FILE, &nsDirectoryService::sComponentRegistry },
 403     { NS_XPCOM_COMPONENT_DIR,         &nsDirectoryService::sComponentDirectory },
 404     { NS_XPCOM_XPTI_REGISTRY_FILE, &nsDirectoryService::sXPTIRegistry },
 405     { NS_GRE_DIR,                  &nsDirectoryService::sGRE_Directory },
 406     { NS_GRE_COMPONENT_DIR,        &nsDirectoryService::sGRE_ComponentDirectory },
 407     { NS_OS_DRIVE_DIR,             &nsDirectoryService::sOS_DriveDirectory },
 408     { NS_OS_TEMP_DIR,              &nsDirectoryService::sOS_TemporaryDirectory },
 409     { NS_OS_CURRENT_PROCESS_DIR,   &nsDirectoryService::sOS_CurrentProcessDirectory },
 410     { NS_OS_CURRENT_WORKING_DIR,   &nsDirectoryService::sOS_CurrentWorkingDirectory },
 411     { NS_OS_HOME_DIR,              &nsDirectoryService::sOS_HomeDirectory },
 412     { NS_OS_DESKTOP_DIR,           &nsDirectoryService::sOS_DesktopDirectory },
 413     { NS_XPCOM_INIT_CURRENT_PROCESS_DIR, nsnull },
 414 #if defined (XP_MACOSX)
 415     { NS_OS_SYSTEM_DIR,                   &nsDirectoryService::sDirectory },
 416     { NS_MAC_TRASH_DIR,                   &nsDirectoryService::sTrashDirectory },
 417     { NS_MAC_STARTUP_DIR,                 &nsDirectoryService::sStartupDirectory },
 418     { NS_MAC_SHUTDOWN_DIR,                &nsDirectoryService::sShutdownDirectory },
 419     { NS_MAC_APPLE_MENU_DIR,              &nsDirectoryService::sAppleMenuDirectory },
 420     { NS_MAC_CONTROL_PANELS_DIR,          &nsDirectoryService::sControlPanelDirectory },
 421     { NS_MAC_EXTENSIONS_DIR,              &nsDirectoryService::sExtensionDirectory },
 422     { NS_MAC_FONTS_DIR,                   &nsDirectoryService::sFontsDirectory },
 423     { NS_MAC_PREFS_DIR,                   &nsDirectoryService::sPreferencesDirectory },
 424     { NS_MAC_DOCUMENTS_DIR,               &nsDirectoryService::sDocumentsDirectory },
 425     { NS_MAC_INTERNET_SEARCH_DIR,         &nsDirectoryService::sInternetSearchDirectory },
 426     { NS_MAC_USER_LIB_DIR,                &nsDirectoryService::sUserLibDirectory },
 427     { NS_OSX_DEFAULT_DOWNLOAD_DIR,        &nsDirectoryService::sDefaultDownloadDirectory },
 428     { NS_OSX_USER_DESKTOP_DIR,            &nsDirectoryService::sUserDesktopDirectory },
 429     { NS_OSX_LOCAL_DESKTOP_DIR,           &nsDirectoryService::sLocalDesktopDirectory },
 430     { NS_OSX_USER_APPLICATIONS_DIR,       &nsDirectoryService::sUserApplicationsDirectory },
 431     { NS_OSX_LOCAL_APPLICATIONS_DIR,      &nsDirectoryService::sLocalApplicationsDirectory },
 432     { NS_OSX_USER_DOCUMENTS_DIR,          &nsDirectoryService::sUserDocumentsDirectory },
 433     { NS_OSX_LOCAL_DOCUMENTS_DIR,         &nsDirectoryService::sLocalDocumentsDirectory },
 434     { NS_OSX_USER_INTERNET_PLUGIN_DIR,    &nsDirectoryService::sUserInternetPlugInDirectory },
 435     { NS_OSX_LOCAL_INTERNET_PLUGIN_DIR,   &nsDirectoryService::sLocalInternetPlugInDirectory },
 436     { NS_OSX_USER_FRAMEWORKS_DIR,         &nsDirectoryService::sUserFrameworksDirectory },
 437     { NS_OSX_LOCAL_FRAMEWORKS_DIR,        &nsDirectoryService::sLocalFrameworksDirectory },
 438     { NS_OSX_USER_PREFERENCES_DIR,        &nsDirectoryService::sUserPreferencesDirectory },
 439     { NS_OSX_LOCAL_PREFERENCES_DIR,       &nsDirectoryService::sLocalPreferencesDirectory },
 440     { NS_OSX_PICTURE_DOCUMENTS_DIR,       &nsDirectoryService::sPictureDocumentsDirectory },
 441     { NS_OSX_MOVIE_DOCUMENTS_DIR,         &nsDirectoryService::sMovieDocumentsDirectory },
 442     { NS_OSX_MUSIC_DOCUMENTS_DIR,         &nsDirectoryService::sMusicDocumentsDirectory },
 443     { NS_OSX_INTERNET_SITES_DIR,          &nsDirectoryService::sInternetSitesDirectory },
 444 #elif defined (XP_WIN)
 445     { NS_OS_SYSTEM_DIR,            &nsDirectoryService::sSystemDirectory },
 446     { NS_WIN_WINDOWS_DIR,          &nsDirectoryService::sWindowsDirectory },
 447     { NS_WIN_PROGRAM_FILES_DIR,    &nsDirectoryService::sWindowsProgramFiles },
 448     { NS_WIN_DESKTOP_DIR,          &nsDirectoryService::sDesktop },
 449     { NS_WIN_PROGRAMS_DIR,         &nsDirectoryService::sPrograms },
 450     { NS_WIN_CONTROLS_DIR,         &nsDirectoryService::sControls },
 451     { NS_WIN_PRINTERS_DIR,         &nsDirectoryService::sPrinters },
 452     { NS_WIN_PERSONAL_DIR,         &nsDirectoryService::sPersonal },
 453     { NS_WIN_FAVORITES_DIR,        &nsDirectoryService::sFavorites },
 454     { NS_WIN_STARTUP_DIR,          &nsDirectoryService::sStartup },
 455     { NS_WIN_RECENT_DIR,           &nsDirectoryService::sRecent },
 456     { NS_WIN_SEND_TO_DIR,          &nsDirectoryService::sSendto },
 457     { NS_WIN_BITBUCKET_DIR,        &nsDirectoryService::sBitbucket },
 458     { NS_WIN_STARTMENU_DIR,        &nsDirectoryService::sStartmenu },
 459     { NS_WIN_DESKTOP_DIRECTORY,    &nsDirectoryService::sDesktopdirectory },
 460     { NS_WIN_DRIVES_DIR,           &nsDirectoryService::sDrives },
 461     { NS_WIN_NETWORK_DIR,          &nsDirectoryService::sNetwork },
 462     { NS_WIN_NETHOOD_DIR,          &nsDirectoryService::sNethood },
 463     { NS_WIN_FONTS_DIR,            &nsDirectoryService::sFonts },
 464     { NS_WIN_TEMPLATES_DIR,        &nsDirectoryService::sTemplates },
 465     { NS_WIN_COMMON_STARTMENU_DIR, &nsDirectoryService::sCommon_Startmenu },
 466     { NS_WIN_COMMON_PROGRAMS_DIR,  &nsDirectoryService::sCommon_Programs },
 467     { NS_WIN_COMMON_STARTUP_DIR,   &nsDirectoryService::sCommon_Startup },
 468     { NS_WIN_COMMON_DESKTOP_DIRECTORY, &nsDirectoryService::sCommon_Desktopdirectory },
 469     { NS_WIN_APPDATA_DIR,          &nsDirectoryService::sAppdata },
 470     { NS_WIN_LOCAL_APPDATA_DIR,    &nsDirectoryService::sLocalAppdata },
 471     { NS_WIN_PRINTHOOD,            &nsDirectoryService::sPrinthood },
 472     { NS_WIN_COOKIES_DIR,          &nsDirectoryService::sWinCookiesDirectory },
 473     { NS_WIN_DEFAULT_DOWNLOAD_DIR, &nsDirectoryService::sDefaultDownloadDirectory },
 474 #elif defined (XP_UNIX)
 475     { NS_UNIX_LOCAL_DIR,           &nsDirectoryService::sLocalDirectory },
 476     { NS_UNIX_LIB_DIR,             &nsDirectoryService::sLibDirectory },
 477     { NS_UNIX_DEFAULT_DOWNLOAD_DIR, &nsDirectoryService::sDefaultDownloadDirectory },
 478     { NS_UNIX_XDG_DESKTOP_DIR,     &nsDirectoryService::sXDGDesktop },
 479     { NS_UNIX_XDG_DOCUMENTS_DIR,   &nsDirectoryService::sXDGDocuments },
 480     { NS_UNIX_XDG_DOWNLOAD_DIR,    &nsDirectoryService::sXDGDownload },
 481     { NS_UNIX_XDG_MUSIC_DIR,       &nsDirectoryService::sXDGMusic },
 482     { NS_UNIX_XDG_PICTURES_DIR,    &nsDirectoryService::sXDGPictures },
 483     { NS_UNIX_XDG_PUBLIC_SHARE_DIR, &nsDirectoryService::sXDGPublicShare },
 484     { NS_UNIX_XDG_TEMPLATES_DIR,   &nsDirectoryService::sXDGTemplates },
 485     { NS_UNIX_XDG_VIDEOS_DIR,      &nsDirectoryService::sXDGVideos },
 486 #elif defined (XP_OS2)
 487     { NS_OS_SYSTEM_DIR,            &nsDirectoryService::sSystemDirectory },
 488     { NS_OS2_DIR,                  &nsDirectoryService::sOS2Directory },
 489 #elif defined (XP_BEOS)
 490     { NS_OS_SYSTEM_DIR,            &nsDirectoryService::sSystemDirectory },
 491     { NS_BEOS_SETTINGS_DIR,        &nsDirectoryService::sSettingsDirectory },
 492 #endif
 493 };
 494
 495 NS_IMETHODIMP
 496 nsDirectoryService::Init()
 497 {
 498     NS_NOTREACHED("nsDirectoryService::Init() for internal use only!");
 499     return NS_OK;
 500 }
 501
 502 nsresult
 503 nsDirectoryService::RealInit()
 504 {
 505     NS_ASSERTION(!gService,
 506                  "nsDirectoryService::RealInit Mustn't initialize twice!");
 507
 508     nsresult rv;
 509
 510     nsRefPtr<nsDirectoryService> self = new nsDirectoryService();
 511     if (!self)
 512         return NS_ERROR_OUT_OF_MEMORY;
 513
 514     rv = NS_NewISupportsArray(getter_AddRefs(((nsDirectoryService*) self)->mProviders));
 515     if (NS_FAILED(rv))
 516         return rv;
 517
 518     NS_RegisterStaticAtoms(directory_atoms, NS_ARRAY_LENGTH(directory_atoms));
 519
 520     // Let the list hold the only reference to the provider.
 521     nsAppFileLocationProvider *defaultProvider = new nsAppFileLocationProvider;
 522     if (!defaultProvider)
 523         return NS_ERROR_OUT_OF_MEMORY;
 524     // AppendElement returns PR_TRUE for success.
 525     rv = ((nsDirectoryService*) self)->mProviders->AppendElement(defaultProvider) ? NS_OK : NS_ERROR_FAILURE;
 526     if (NS_FAILED(rv))
 527         return rv;
 528
 529     self.swap(gService);
 530     return NS_OK;
 531 }
 532
 533 PRBool
 534 nsDirectoryService::ReleaseValues(nsHashKey* key, void* data, void* closure)
 535 {
 536     nsISupports* value = (nsISupports*)data;
 537     NS_IF_RELEASE(value);
 538     return PR_TRUE;
 539 }
 540
 541 nsDirectoryService::~nsDirectoryService()
 542 {
 543 }
 544
 545 NS_IMPL_THREADSAFE_ISUPPORTS4(nsDirectoryService, nsIProperties, nsIDirectoryService, nsIDirectoryServiceProvider, nsIDirectoryServiceProvider2)
 546
 547
 548 NS_IMETHODIMP
 549 nsDirectoryService::Undefine(const char* prop)
 550 {
 551     NS_ENSURE_ARG(prop);
 552
 553     nsCStringKey key(prop);
 554     if (!mHashtable.Exists(&key))
 555         return NS_ERROR_FAILURE;
 556
 557     mHashtable.Remove (&key);
 558     return NS_OK;
 559  }
 560
 561 NS_IMETHODIMP
 562 nsDirectoryService::GetKeys(PRUint32 *count, char ***keys)
 563 {
 564     return NS_ERROR_NOT_IMPLEMENTED;
 565 }
 566
 567 struct FileData
 568 {
 569   FileData(const char* aProperty,
 570            const nsIID& aUUID) :
 571     property(aProperty),
 572     data(nsnull),
 573     persistent(PR_TRUE),
 574     uuid(aUUID) {}
 575
 576   const char*   property;
 577   nsISupports*  data;
 578   PRBool        persistent;
 579   const nsIID&  uuid;
 580 };
 581
 582 static PRBool FindProviderFile(nsISupports* aElement, void *aData)
 583 {
 584   nsresult rv;
 585   FileData* fileData = (FileData*)aData;
 586   if (fileData->uuid.Equals(NS_GET_IID(nsISimpleEnumerator)))
 587   {
 588       // Not all providers implement this iface
 589       nsCOMPtr<nsIDirectoryServiceProvider2> prov2 = do_QueryInterface(aElement);
 590       if (prov2)
 591       {
 592           nsCOMPtr<nsISimpleEnumerator> newFiles;
 593           rv = prov2->GetFiles(fileData->property, getter_AddRefs(newFiles));
 594           if (NS_SUCCEEDED(rv) && newFiles) {
 595               if (fileData->data) {
 596                   nsCOMPtr<nsISimpleEnumerator> unionFiles;
 597
 598                   NS_NewUnionEnumerator(getter_AddRefs(unionFiles),
 599                                         (nsISimpleEnumerator*) fileData->data, newFiles);
 600
 601                   if (unionFiles)
 602                       unionFiles.swap(* (nsISimpleEnumerator**) &fileData->data);
 603               }
 604               else
 605               {
 606                   NS_ADDREF(fileData->data = newFiles);
 607               }
 608
 609               fileData->persistent = PR_FALSE; // Enumerators can never be persistent
 610               return rv == NS_SUCCESS_AGGREGATE_RESULT;
 611           }
 612       }
 613   }
 614   else
 615   {
 616       nsCOMPtr<nsIDirectoryServiceProvider> prov = do_QueryInterface(aElement);
 617       if (prov)
 618       {
 619           rv = prov->GetFile(fileData->property, &fileData->persistent, (nsIFile **)&fileData->data);
 620           if (NS_SUCCEEDED(rv) && fileData->data)
 621               return PR_FALSE;
 622       }
 623   }
 624
 625   return PR_TRUE;
 626 }
 627
 628 NS_IMETHODIMP
 629 nsDirectoryService::Get(const char* prop, const nsIID & uuid, void* *result)
 630 {
 631     NS_ENSURE_ARG(prop);
 632
 633     nsCStringKey key(prop);
 634
 635     nsCOMPtr<nsISupports> value = dont_AddRef(mHashtable.Get(&key));
 636
 637     if (value)
 638     {
 639         nsCOMPtr<nsIFile> cloneFile;
 640         nsCOMPtr<nsIFile> cachedFile = do_QueryInterface(value);
 641         NS_ASSERTION(cachedFile,
 642                      "nsDirectoryService::Get nsIFile expected");
 643
 644         cachedFile->Clone(getter_AddRefs(cloneFile));
 645         return cloneFile->QueryInterface(uuid, result);
 646     }
 647
 648     // it is not one of our defaults, lets check any providers
 649     FileData fileData(prop, uuid);
 650
 651     mProviders->EnumerateBackwards(FindProviderFile, &fileData);
 652     if (fileData.data)
 653     {
 654         if (fileData.persistent)
 655         {
 656             Set(prop, static_cast<nsIFile*>(fileData.data));
 657         }
 658         nsresult rv = (fileData.data)->QueryInterface(uuid, result);
 659         NS_RELEASE(fileData.data);  // addref occurs in FindProviderFile()
 660         return rv;
 661     }
 662
 663     FindProviderFile(static_cast<nsIDirectoryServiceProvider*>(this), &fileData);
 664     if (fileData.data)
 665     {
 666         if (fileData.persistent)
 667         {
 668             Set(prop, static_cast<nsIFile*>(fileData.data));
 669         }
 670         nsresult rv = (fileData.data)->QueryInterface(uuid, result);
 671         NS_RELEASE(fileData.data);  // addref occurs in FindProviderFile()
 672         return rv;
 673     }
 674
 675     return NS_ERROR_FAILURE;
 676 }
 677
 678 NS_IMETHODIMP
 679 nsDirectoryService::Set(const char* prop, nsISupports* value)
 680 {
 681     NS_ENSURE_ARG(prop);
 682
 683     nsCStringKey key(prop);
 684     if (mHashtable.Exists(&key) || value == nsnull)
 685         return NS_ERROR_FAILURE;
 686
 687     nsCOMPtr<nsIFile> ourFile;
 688     value->QueryInterface(NS_GET_IID(nsIFile), getter_AddRefs(ourFile));
 689     if (ourFile)
 690     {
 691       nsCOMPtr<nsIFile> cloneFile;
 692       ourFile->Clone (getter_AddRefs (cloneFile));
 693       mHashtable.Put(&key, cloneFile);
 694
 695       return NS_OK;
 696     }
 697
 698     return NS_ERROR_FAILURE;
 699 }
 700
 701 NS_IMETHODIMP
 702 nsDirectoryService::Has(const char *prop, PRBool *_retval)
 703 {
 704     NS_ENSURE_ARG(prop);
 705
 706     *_retval = PR_FALSE;
 707     nsCOMPtr<nsIFile> value;
 708     nsresult rv = Get(prop, NS_GET_IID(nsIFile), getter_AddRefs(value));
 709     if (NS_FAILED(rv))
 710         return NS_OK;
 711
 712     if (value)
 713     {
 714         *_retval = PR_TRUE;
 715     }
 716
 717     return rv;
 718 }
 719
 720 NS_IMETHODIMP
 721 nsDirectoryService::RegisterProvider(nsIDirectoryServiceProvider *prov)
 722 {
 723     nsresult rv;
 724     if (!prov)
 725         return NS_ERROR_FAILURE;
 726     if (!mProviders)
 727         return NS_ERROR_NOT_INITIALIZED;
 728
 729     nsCOMPtr<nsISupports> supports = do_QueryInterface(prov, &rv);
 730     if (NS_FAILED(rv)) return rv;
 731
 732     // AppendElement returns PR_TRUE for success.
 733     return mProviders->AppendElement(supports) ? NS_OK : NS_ERROR_FAILURE;
 734 }
 735
 736 void
 737 nsDirectoryService::RegisterCategoryProviders()
 738 {
 739     nsCOMPtr<nsICategoryManager> catman
 740         (do_GetService(NS_CATEGORYMANAGER_CONTRACTID));
 741     if (!catman)
 742         return;
 743
 744     nsCOMPtr<nsISimpleEnumerator> entries;
 745     catman->EnumerateCategory(XPCOM_DIRECTORY_PROVIDER_CATEGORY,
 746                               getter_AddRefs(entries));
 747
 748     nsCOMPtr<nsIUTF8StringEnumerator> strings(do_QueryInterface(entries));
 749     if (!strings)
 750         return;
 751
 752     PRBool more;
 753     while (NS_SUCCEEDED(strings->HasMore(&more)) && more) {
 754         nsCAutoString entry;
 755         strings->GetNext(entry);
 756
 757         nsXPIDLCString contractID;
 758         catman->GetCategoryEntry(XPCOM_DIRECTORY_PROVIDER_CATEGORY, entry.get(), getter_Copies(contractID));
 759
 760         if (contractID) {
 761             nsCOMPtr<nsIDirectoryServiceProvider> provider = do_GetService(contractID.get());
 762             if (provider)
 763                 RegisterProvider(provider);
 764         }
 765     }
 766 }
 767
 768 NS_IMETHODIMP
 769 nsDirectoryService::UnregisterProvider(nsIDirectoryServiceProvider *prov)
 770 {
 771     nsresult rv;
 772     if (!prov)
 773         return NS_ERROR_FAILURE;
 774     if (!mProviders)
 775         return NS_ERROR_NOT_INITIALIZED;
 776
 777     nsCOMPtr<nsISupports> supports = do_QueryInterface(prov, &rv);
 778     if (NS_FAILED(rv)) return rv;
 779
 780     // RemoveElement returns PR_TRUE for success.
 781     return mProviders->RemoveElement(supports) ? NS_OK : NS_ERROR_FAILURE;
 782 }
 783
 784 // DO NOT ADD ANY LOCATIONS TO THIS FUNCTION UNTIL YOU TALK TO: dougt@netscape.com.
 785 // This is meant to be a place of xpcom or system specific file locations, not
 786 // application specific locations.  If you need the later, register a callback for
 787 // your application.
 788
 789 NS_IMETHODIMP
 790 nsDirectoryService::GetFile(const char *prop, PRBool *persistent, nsIFile **_retval)
 791 {
 792     nsCOMPtr<nsILocalFile> localFile;
 793     nsresult rv = NS_ERROR_FAILURE;
 794
 795     *_retval = nsnull;
 796     *persistent = PR_TRUE;
 797
 798     nsIAtom* inAtom = NS_NewAtom(prop);
 799
 800     // check to see if it is one of our defaults
 801
 802     if (inAtom == nsDirectoryService::sCurrentProcess ||
 803         inAtom == nsDirectoryService::sOS_CurrentProcessDirectory )
 804     {
 805         rv = GetCurrentProcessDirectory(getter_AddRefs(localFile));
 806     }
 807     else if (inAtom == nsDirectoryService::sComponentRegistry)
 808     {
 809         rv = GetCurrentProcessDirectory(getter_AddRefs(localFile));
 810         if (!localFile)
 811             return NS_ERROR_FAILURE;
 812
 813         localFile->AppendNative(COMPONENT_DIRECTORY);
 814         localFile->AppendNative(COMPONENT_REGISTRY_NAME);
 815     }
 816     else if (inAtom == nsDirectoryService::sXPTIRegistry)
 817     {
 818         rv = GetCurrentProcessDirectory(getter_AddRefs(localFile));
 819         if (!localFile)
 820             return NS_ERROR_FAILURE;
 821
 822         localFile->AppendNative(COMPONENT_DIRECTORY);
 823         localFile->AppendNative(XPTI_REGISTRY_NAME);
 824     }
 825
 826     // Unless otherwise set, the core pieces of the GRE exist
 827     // in the current process directory.
 828     else if (inAtom == nsDirectoryService::sGRE_Directory)
 829     {
 830         rv = GetCurrentProcessDirectory(getter_AddRefs(localFile));
 831     }
 832     // the GRE components directory is relative to the GRE directory
 833     // by default; applications may override this behavior in special
 834     // cases
 835     else if (inAtom == nsDirectoryService::sGRE_ComponentDirectory)
 836     {
 837         rv = Get(NS_GRE_DIR, NS_GET_IID(nsILocalFile), getter_AddRefs(localFile));
 838         if (localFile)
 839              localFile->AppendNative(COMPONENT_DIRECTORY);
 840     }
 841     else if (inAtom == nsDirectoryService::sComponentDirectory)
 842     {
 843         rv = GetCurrentProcessDirectory(getter_AddRefs(localFile));
 844         if (localFile)
 845             localFile->AppendNative(COMPONENT_DIRECTORY);
 846     }
 847     else if (inAtom == nsDirectoryService::sOS_DriveDirectory)
 848     {
 849         rv = GetSpecialSystemDirectory(OS_DriveDirectory, getter_AddRefs(localFile));
 850     }
 851     else if (inAtom == nsDirectoryService::sOS_TemporaryDirectory)
 852     {
 853         rv = GetSpecialSystemDirectory(OS_TemporaryDirectory, getter_AddRefs(localFile));
 854     }
 855     else if (inAtom == nsDirectoryService::sOS_CurrentProcessDirectory)
 856     {
 857         rv = GetSpecialSystemDirectory(OS_CurrentProcessDirectory, getter_AddRefs(localFile));
 858     }
 859     else if (inAtom == nsDirectoryService::sOS_CurrentWorkingDirectory)
 860     {
 861         rv = GetSpecialSystemDirectory(OS_CurrentWorkingDirectory, getter_AddRefs(localFile));
 862     }
 863
 864 #if defined(XP_MACOSX)
 865     else if (inAtom == nsDirectoryService::sDirectory)
 866     {
 867         rv = GetOSXFolderType(kClassicDomain, kSystemFolderType, getter_AddRefs(localFile));
 868     }
 869     else if (inAtom == nsDirectoryService::sTrashDirectory)
 870     {
 871         rv = GetOSXFolderType(kClassicDomain, kTrashFolderType, getter_AddRefs(localFile));
 872     }
 873     else if (inAtom == nsDirectoryService::sStartupDirectory)
 874     {
 875         rv = GetOSXFolderType(kClassicDomain, kStartupFolderType, getter_AddRefs(localFile));
 876     }
 877     else if (inAtom == nsDirectoryService::sShutdownDirectory)
 878     {
 879         rv = GetOSXFolderType(kClassicDomain, kShutdownFolderType, getter_AddRefs(localFile));
 880     }
 881     else if (inAtom == nsDirectoryService::sAppleMenuDirectory)
 882     {
 883         rv = GetOSXFolderType(kClassicDomain, kAppleMenuFolderType, getter_AddRefs(localFile));
 884     }
 885     else if (inAtom == nsDirectoryService::sControlPanelDirectory)
 886     {
 887         rv = GetOSXFolderType(kClassicDomain, kControlPanelFolderType, getter_AddRefs(localFile));
 888     }
 889     else if (inAtom == nsDirectoryService::sExtensionDirectory)
 890     {
 891         rv = GetOSXFolderType(kClassicDomain, kExtensionFolderType, getter_AddRefs(localFile));
 892     }
 893     else if (inAtom == nsDirectoryService::sFontsDirectory)
 894     {
 895         rv = GetOSXFolderType(kClassicDomain, kFontsFolderType, getter_AddRefs(localFile));
 896     }
 897     else if (inAtom == nsDirectoryService::sPreferencesDirectory)
 898     {
 899         rv = GetOSXFolderType(kClassicDomain, kPreferencesFolderType, getter_AddRefs(localFile));
 900     }
 901     else if (inAtom == nsDirectoryService::sDocumentsDirectory)
 902     {
 903         rv = GetOSXFolderType(kClassicDomain, kDocumentsFolderType, getter_AddRefs(localFile));
 904     }
 905     else if (inAtom == nsDirectoryService::sInternetSearchDirectory)
 906     {
 907         rv = GetOSXFolderType(kClassicDomain, kInternetSearchSitesFolderType, getter_AddRefs(localFile));
 908     }
 909     else if (inAtom == nsDirectoryService::sUserLibDirectory)
 910     {
 911         rv = GetOSXFolderType(kUserDomain, kDomainLibraryFolderType, getter_AddRefs(localFile));
 912     }
 913     else if (inAtom == nsDirectoryService::sOS_HomeDirectory)
 914     {
 915         rv = GetOSXFolderType(kUserDomain, kDomainTopLevelFolderType, getter_AddRefs(localFile));
 916     }
 917     else if (inAtom == nsDirectoryService::sDefaultDownloadDirectory)
 918     {
 919         NS_NewLocalFile(EmptyString(), PR_TRUE, getter_AddRefs(localFile));
 920         nsCOMPtr<nsILocalFileMac> localMacFile(do_QueryInterface(localFile));
 921
 922         if (localMacFile)
 923         {
 924             OSErr err;
 925             ICInstance icInstance;
 926
 927             err = ::ICStart(&icInstance, 'XPCM');
 928             if (err == noErr)
 929             {
 930                 // ICGetPref() crashes when getting the download directory if the download
 931                 // directory has never been specified (e.g. a new user account), bug 265903.
 932                 // To work around this we enumerate through the IC prefs to see if the
 933                 // download directory has been specified before trying to obtain it.
 934                 long numPrefs = 0;
 935                 err = ::ICCountPref(icInstance, &numPrefs);
 936                 if (err == noErr)
 937                 {
 938                     for ( long i = 0; i < numPrefs; ++i )
 939                     {
 940                         Str255 key;
 941                         err = ::ICGetIndPref(icInstance, i, key);
 942                         if ( err == noErr && ( PLstrcmp( key, kICDownloadFolder ) == 0 ) )
 943                         {
 944                             ICAttr attrs;
 945                             ICFileSpec icFileSpec;
 946                             long size = kICFileSpecHeaderSize;
 947                             err = ::ICGetPref(icInstance, kICDownloadFolder, &attrs, &icFileSpec, &size);
 948                             if (err == noErr || (err == icTruncatedErr && size >= kICFileSpecHeaderSize))
 949                             {
 950                                 rv = localMacFile->InitWithFSSpec(&icFileSpec.fss);
 951                             }
 952                             break;
 953                         }
 954                     }
 955                 }
 956                 ::ICStop(icInstance);
 957             }
 958
 959             if (NS_FAILED(rv))
 960             {
 961                 // We got an error getting the DL folder from IC so try finding the user's Desktop folder
 962                 rv = GetOSXFolderType(kUserDomain, kDesktopFolderType, getter_AddRefs(localFile));
 963             }
 964         }
 965
 966         // Don't cache the DL directory as the user may change it while we're running.
 967         // Negligible perf hit as this directory is only requested for downloads
 968         *persistent = PR_FALSE;
 969     }
 970     else if (inAtom == nsDirectoryService::sUserDesktopDirectory ||
 971              inAtom == nsDirectoryService::sOS_DesktopDirectory)
 972     {
 973         rv = GetOSXFolderType(kUserDomain, kDesktopFolderType, getter_AddRefs(localFile));
 974     }
 975     else if (inAtom == nsDirectoryService::sLocalDesktopDirectory)
 976     {
 977         rv = GetOSXFolderType(kLocalDomain, kDesktopFolderType, getter_AddRefs(localFile));
 978     }
 979     else if (inAtom == nsDirectoryService::sUserApplicationsDirectory)
 980     {
 981         rv = GetOSXFolderType(kUserDomain, kApplicationsFolderType, getter_AddRefs(localFile));
 982     }
 983     else if (inAtom == nsDirectoryService::sLocalApplicationsDirectory)
 984     {
 985         rv = GetOSXFolderType(kLocalDomain, kApplicationsFolderType, getter_AddRefs(localFile));
 986     }
 987     else if (inAtom == nsDirectoryService::sUserDocumentsDirectory)
 988     {
 989         rv = GetOSXFolderType(kUserDomain, kDocumentsFolderType, getter_AddRefs(localFile));
 990     }
 991     else if (inAtom == nsDirectoryService::sLocalDocumentsDirectory)
 992     {
 993         rv = GetOSXFolderType(kLocalDomain, kDocumentsFolderType, getter_AddRefs(localFile));
 994     }
 995     else if (inAtom == nsDirectoryService::sUserInternetPlugInDirectory)
 996     {
 997         rv = GetOSXFolderType(kUserDomain, kInternetPlugInFolderType, getter_AddRefs(localFile));
 998     }
 999     else if (inAtom == nsDirectoryService::sLocalInternetPlugInDirectory)
1000     {
1001         rv = GetOSXFolderType(kLocalDomain, kInternetPlugInFolderType, getter_AddRefs(localFile));
1002     }
1003     else if (inAtom == nsDirectoryService::sUserFrameworksDirectory)
1004     {
1005         rv = GetOSXFolderType(kUserDomain, kFrameworksFolderType, getter_AddRefs(localFile));
1006     }
1007     else if (inAtom == nsDirectoryService::sLocalFrameworksDirectory)
1008     {
1009         rv = GetOSXFolderType(kLocalDomain, kFrameworksFolderType, getter_AddRefs(localFile));
1010     }
1011     else if (inAtom == nsDirectoryService::sUserPreferencesDirectory)
1012     {
1013         rv = GetOSXFolderType(kUserDomain, kPreferencesFolderType, getter_AddRefs(localFile));
1014     }
1015     else if (inAtom == nsDirectoryService::sLocalPreferencesDirectory)
1016     {
1017         rv = GetOSXFolderType(kLocalDomain, kPreferencesFolderType, getter_AddRefs(localFile));
1018     }
1019     else if (inAtom == nsDirectoryService::sPictureDocumentsDirectory)
1020     {
1021         rv = GetOSXFolderType(kUserDomain, kPictureDocumentsFolderType, getter_AddRefs(localFile));
1022     }
1023     else if (inAtom == nsDirectoryService::sMovieDocumentsDirectory)
1024     {
1025         rv = GetOSXFolderType(kUserDomain, kMovieDocumentsFolderType, getter_AddRefs(localFile));
1026     }
1027     else if (inAtom == nsDirectoryService::sMusicDocumentsDirectory)
1028     {
1029         rv = GetOSXFolderType(kUserDomain, kMusicDocumentsFolderType, getter_AddRefs(localFile));
1030     }
1031     else if (inAtom == nsDirectoryService::sInternetSitesDirectory)
1032     {
1033         rv = GetOSXFolderType(kUserDomain, kInternetSitesFolderType, getter_AddRefs(localFile));
1034     }
1035 #elif defined (XP_WIN)
1036     else if (inAtom == nsDirectoryService::sSystemDirectory)
1037     {
1038         rv = GetSpecialSystemDirectory(Win_SystemDirectory, getter_AddRefs(localFile));
1039     }
1040     else if (inAtom == nsDirectoryService::sWindowsDirectory)
1041     {
1042         rv = GetSpecialSystemDirectory(Win_WindowsDirectory, getter_AddRefs(localFile));
1043     }
1044     else if (inAtom == nsDirectoryService::sWindowsProgramFiles)
1045     {
1046         rv = GetSpecialSystemDirectory(Win_ProgramFiles, getter_AddRefs(localFile));
1047     }
1048     else if (inAtom == nsDirectoryService::sOS_HomeDirectory)
1049     {
1050         rv = GetSpecialSystemDirectory(Win_HomeDirectory, getter_AddRefs(localFile));
1051     }
1052     else if (inAtom == nsDirectoryService::sDesktop)
1053     {
1054         rv = GetSpecialSystemDirectory(Win_Desktop, getter_AddRefs(localFile));
1055     }
1056     else if (inAtom == nsDirectoryService::sPrograms)
1057     {
1058         rv = GetSpecialSystemDirectory(Win_Programs, getter_AddRefs(localFile));
1059     }
1060     else if (inAtom == nsDirectoryService::sControls)
1061     {
1062         rv = GetSpecialSystemDirectory(Win_Controls, getter_AddRefs(localFile));
1063     }
1064     else if (inAtom == nsDirectoryService::sPrinters)
1065     {
1066         rv = GetSpecialSystemDirectory(Win_Printers, getter_AddRefs(localFile));
1067     }
1068     else if (inAtom == nsDirectoryService::sPersonal)
1069     {
1070         rv = GetSpecialSystemDirectory(Win_Personal, getter_AddRefs(localFile));
1071     }
1072     else if (inAtom == nsDirectoryService::sFavorites)
1073     {
1074         rv = GetSpecialSystemDirectory(Win_Favorites, getter_AddRefs(localFile));
1075     }
1076     else if (inAtom == nsDirectoryService::sStartup)
1077     {
1078         rv = GetSpecialSystemDirectory(Win_Startup, getter_AddRefs(localFile));
1079     }
1080     else if (inAtom == nsDirectoryService::sRecent)
1081     {
1082         rv = GetSpecialSystemDirectory(Win_Recent, getter_AddRefs(localFile));
1083     }
1084     else if (inAtom == nsDirectoryService::sSendto)
1085     {
1086         rv = GetSpecialSystemDirectory(Win_Sendto, getter_AddRefs(localFile));
1087     }
1088     else if (inAtom == nsDirectoryService::sBitbucket)
1089     {
1090         rv = GetSpecialSystemDirectory(Win_Bitbucket, getter_AddRefs(localFile));
1091     }
1092     else if (inAtom == nsDirectoryService::sStartmenu)
1093     {
1094         rv = GetSpecialSystemDirectory(Win_Startmenu, getter_AddRefs(localFile));
1095     }
1096     else if (inAtom == nsDirectoryService::sDesktopdirectory ||
1097              inAtom == nsDirectoryService::sOS_DesktopDirectory)
1098     {
1099         rv = GetSpecialSystemDirectory(Win_Desktopdirectory, getter_AddRefs(localFile));
1100     }
1101     else if (inAtom == nsDirectoryService::sDrives)
1102     {
1103         rv = GetSpecialSystemDirectory(Win_Drives, getter_AddRefs(localFile));
1104     }
1105     else if (inAtom == nsDirectoryService::sNetwork)
1106     {
1107         rv = GetSpecialSystemDirectory(Win_Network, getter_AddRefs(localFile));
1108     }
1109     else if (inAtom == nsDirectoryService::sNethood)
1110     {
1111         rv = GetSpecialSystemDirectory(Win_Nethood, getter_AddRefs(localFile));
1112     }
1113     else if (inAtom == nsDirectoryService::sFonts)
1114     {
1115         rv = GetSpecialSystemDirectory(Win_Fonts, getter_AddRefs(localFile));
1116     }
1117     else if (inAtom == nsDirectoryService::sTemplates)
1118     {
1119         rv = GetSpecialSystemDirectory(Win_Templates, getter_AddRefs(localFile));
1120     }
1121     else if (inAtom == nsDirectoryService::sCommon_Startmenu)
1122     {
1123         rv = GetSpecialSystemDirectory(Win_Common_Startmenu, getter_AddRefs(localFile));
1124     }
1125     else if (inAtom == nsDirectoryService::sCommon_Programs)
1126     {
1127         rv = GetSpecialSystemDirectory(Win_Common_Programs, getter_AddRefs(localFile));
1128     }
1129     else if (inAtom == nsDirectoryService::sCommon_Startup)
1130     {
1131         rv = GetSpecialSystemDirectory(Win_Common_Startup, getter_AddRefs(localFile));
1132     }
1133     else if (inAtom == nsDirectoryService::sCommon_Desktopdirectory)
1134     {
1135         rv = GetSpecialSystemDirectory(Win_Common_Desktopdirectory, getter_AddRefs(localFile));
1136     }
1137     else if (inAtom == nsDirectoryService::sAppdata)
1138     {
1139         rv = GetSpecialSystemDirectory(Win_Appdata, getter_AddRefs(localFile));
1140     }
1141     else if (inAtom == nsDirectoryService::sLocalAppdata)
1142     {
1143         rv = GetSpecialSystemDirectory(Win_LocalAppdata, getter_AddRefs(localFile));
1144     }
1145     else if (inAtom == nsDirectoryService::sPrinthood)
1146     {
1147         rv = GetSpecialSystemDirectory(Win_Printhood, getter_AddRefs(localFile));
1148     }
1149     else if (inAtom == nsDirectoryService::sWinCookiesDirectory)
1150     {
1151         rv = GetSpecialSystemDirectory(Win_Cookies, getter_AddRefs(localFile));
1152     }
1153     else if (inAtom == nsDirectoryService::sDefaultDownloadDirectory)
1154     {
1155         rv = GetSpecialSystemDirectory(Win_Downloads, getter_AddRefs(localFile));
1156     }
1157 #elif defined (XP_UNIX)
1158
1159     else if (inAtom == nsDirectoryService::sLocalDirectory)
1160     {
1161         rv = GetSpecialSystemDirectory(Unix_LocalDirectory, getter_AddRefs(localFile));
1162     }
1163     else if (inAtom == nsDirectoryService::sLibDirectory)
1164     {
1165         rv = GetSpecialSystemDirectory(Unix_LibDirectory, getter_AddRefs(localFile));
1166     }
1167     else if (inAtom == nsDirectoryService::sOS_HomeDirectory)
1168     {
1169         rv = GetSpecialSystemDirectory(Unix_HomeDirectory, getter_AddRefs(localFile));
1170     }
1171     else if (inAtom == nsDirectoryService::sXDGDesktop ||
1172              inAtom == nsDirectoryService::sOS_DesktopDirectory)
1173     {
1174         rv = GetSpecialSystemDirectory(Unix_XDG_Desktop, getter_AddRefs(localFile));
1175         *persistent = PR_FALSE;
1176     }
1177     else if (inAtom == nsDirectoryService::sXDGDocuments)
1178     {
1179         rv = GetSpecialSystemDirectory(Unix_XDG_Documents, getter_AddRefs(localFile));
1180         *persistent = PR_FALSE;
1181     }
1182     else if (inAtom == nsDirectoryService::sXDGDownload ||
1183              inAtom == nsDirectoryService::sDefaultDownloadDirectory)
1184     {
1185         rv = GetSpecialSystemDirectory(Unix_XDG_Download, getter_AddRefs(localFile));
1186         *persistent = PR_FALSE;
1187     }
1188     else if (inAtom == nsDirectoryService::sXDGMusic)
1189     {
1190         rv = GetSpecialSystemDirectory(Unix_XDG_Music, getter_AddRefs(localFile));
1191         *persistent = PR_FALSE;
1192     }
1193     else if (inAtom == nsDirectoryService::sXDGPictures)
1194     {
1195         rv = GetSpecialSystemDirectory(Unix_XDG_Pictures, getter_AddRefs(localFile));
1196         *persistent = PR_FALSE;
1197     }
1198     else if (inAtom == nsDirectoryService::sXDGPublicShare)
1199     {
1200         rv = GetSpecialSystemDirectory(Unix_XDG_PublicShare, getter_AddRefs(localFile));
1201         *persistent = PR_FALSE;
1202     }
1203     else if (inAtom == nsDirectoryService::sXDGTemplates)
1204     {
1205         rv = GetSpecialSystemDirectory(Unix_XDG_Templates, getter_AddRefs(localFile));
1206         *persistent = PR_FALSE;
1207     }
1208     else if (inAtom == nsDirectoryService::sXDGVideos)
1209     {
1210         rv = GetSpecialSystemDirectory(Unix_XDG_Videos, getter_AddRefs(localFile));
1211         *persistent = PR_FALSE;
1212     }
1213 #elif defined (XP_OS2)
1214     else if (inAtom == nsDirectoryService::sSystemDirectory)
1215     {
1216         rv = GetSpecialSystemDirectory(OS2_SystemDirectory, getter_AddRefs(localFile));
1217     }
1218     else if (inAtom == nsDirectoryService::sOS2Directory)
1219     {
1220         rv = GetSpecialSystemDirectory(OS2_OS2Directory, getter_AddRefs(localFile));
1221     }
1222     else if (inAtom == nsDirectoryService::sOS_HomeDirectory)
1223     {
1224         rv = GetSpecialSystemDirectory(OS2_HomeDirectory, getter_AddRefs(localFile));
1225     }
1226     else if (inAtom == nsDirectoryService::sOS_DesktopDirectory)
1227     {
1228         rv = GetSpecialSystemDirectory(OS2_DesktopDirectory, getter_AddRefs(localFile));
1229     }
1230 #elif defined (XP_BEOS)
1231     else if (inAtom == nsDirectoryService::sSettingsDirectory)
1232     {
1233         rv = GetSpecialSystemDirectory(BeOS_SettingsDirectory, getter_AddRefs(localFile));
1234     }
1235     else if (inAtom == nsDirectoryService::sOS_HomeDirectory)
1236     {
1237         rv = GetSpecialSystemDirectory(BeOS_HomeDirectory, getter_AddRefs(localFile));
1238     }
1239     else if (inAtom == nsDirectoryService::sOS_DesktopDirectory)
1240     {
1241         rv = GetSpecialSystemDirectory(BeOS_DesktopDirectory, getter_AddRefs(localFile));
1242     }
1243     else if (inAtom == nsDirectoryService::sSystemDirectory)
1244     {
1245         rv = GetSpecialSystemDirectory(BeOS_SystemDirectory, getter_AddRefs(localFile));
1246     }
1247 #endif
1248
1249
1250     NS_RELEASE(inAtom);
1251
1252     if (localFile && NS_SUCCEEDED(rv))
1253         return localFile->QueryInterface(NS_GET_IID(nsIFile), (void**)_retval);
1254 #ifdef DEBUG_dougt
1255     printf("Failed to find directory for key: %s\n", prop);
1256 #endif
1257     return rv;
1258 }
1259
1260 NS_IMETHODIMP
1261 nsDirectoryService::GetFiles(const char *prop, nsISimpleEnumerator **_retval)
1262 {
1263     NS_ENSURE_ARG_POINTER(_retval);
1264     *_retval = nsnull;
1265
1266     return NS_ERROR_FAILURE;
1267 }