toolkit/xre/nsXREDirProvider.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   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) 2002
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *  Brian Ryner <bryner@brianryner.com>
  24  *  Benjamin Smedberg <bsmedberg@covad.net>
  25  *  Ben Goodger <ben@mozilla.org>
  26  *  Jens Bannmann <jens.b@web.de>
  27  *
  28  * Alternatively, the contents of this file may be used under the terms of
  29  * either the GNU General Public License Version 2 or later (the "GPL"), or
  30  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  31  * in which case the provisions of the GPL or the LGPL are applicable instead
  32  * of those above. If you wish to allow use of your version of this file only
  33  * under the terms of either the GPL or the LGPL, and not to allow others to
  34  * use your version of this file under the terms of the MPL, indicate your
  35  * decision by deleting the provisions above and replace them with the notice
  36  * and other provisions required by the GPL or the LGPL. If you do not delete
  37  * the provisions above, a recipient may use your version of this file under
  38  * the terms of any one of the MPL, the GPL or the LGPL.
  39  *
  40  * ***** END LICENSE BLOCK ***** */
  41
  42 #include "nsAppRunner.h"
  43 #include "nsXREDirProvider.h"
  44
  45 #include "jsapi.h"
  46
  47 #include "nsIJSContextStack.h"
  48 #include "nsIDirectoryEnumerator.h"
  49 #include "nsILocalFile.h"
  50 #include "nsIObserverService.h"
  51 #include "nsIProfileChangeStatus.h"
  52 #include "nsISimpleEnumerator.h"
  53 #include "nsIToolkitChromeRegistry.h"
  54
  55 #include "nsAppDirectoryServiceDefs.h"
  56 #include "nsDirectoryServiceDefs.h"
  57 #include "nsDirectoryServiceUtils.h"
  58 #include "nsXULAppAPI.h"
  59
  60 #include "nsINIParser.h"
  61 #include "nsDependentString.h"
  62 #include "nsCOMArray.h"
  63 #include "nsArrayEnumerator.h"
  64 #include "nsEnumeratorUtils.h"
  65 #include "nsReadableUtils.h"
  66
  67 #include <stdlib.h>
  68
  69 #ifdef XP_WIN
  70 #include <windows.h>
  71 #include <shlobj.h>
  72 // This is not defined by VC6.
  73 #ifndef CSIDL_LOCAL_APPDATA
  74 #define CSIDL_LOCAL_APPDATA             0x001C
  75 #endif
  76 #endif
  77 #ifdef XP_MACOSX
  78 #include "nsILocalFileMac.h"
  79 #endif
  80 #ifdef XP_BEOS
  81 #include <be/kernel/image.h>
  82 #include <FindDirectory.h>
  83 #endif
  84 #ifdef XP_UNIX
  85 #include <ctype.h>
  86 #endif
  87 #ifdef XP_OS2
  88 #define INCL_DOS
  89 #include <os2.h>
  90 #endif
  91
  92 #if defined(XP_MACOSX)
  93 #define APP_REGISTRY_NAME "Application Registry"
  94 #elif defined(XP_WIN) || defined(XP_OS2)
  95 #define APP_REGISTRY_NAME "registry.dat"
  96 #else
  97 #define APP_REGISTRY_NAME "appreg"
  98 #endif
  99
 100 #define PREF_OVERRIDE_DIRNAME "preferences"
 101
 102 nsXREDirProvider* gDirServiceProvider = nsnull;
 103
 104 nsXREDirProvider::nsXREDirProvider() :
 105   mProfileNotified(PR_FALSE),
 106   mExtensionsLoaded(PR_FALSE)
 107 {
 108   gDirServiceProvider = this;
 109 }
 110
 111 nsXREDirProvider::~nsXREDirProvider()
 112 {
 113   gDirServiceProvider = nsnull;
 114 }
 115
 116 nsresult
 117 nsXREDirProvider::Initialize(nsIFile *aXULAppDir,
 118                              nsILocalFile *aGREDir,
 119                              nsIDirectoryServiceProvider* aAppProvider)
 120 {
 121   NS_ENSURE_ARG(aGREDir);
 122
 123   mAppProvider = aAppProvider;
 124   mXULAppDir = aXULAppDir;
 125   mGREDir = aGREDir;
 126
 127   return NS_OK;
 128 }
 129
 130 nsresult
 131 nsXREDirProvider::SetProfile(nsIFile* aDir, nsIFile* aLocalDir)
 132 {
 133   NS_ASSERTION(aDir && aLocalDir, "We don't support no-profile apps yet!");
 134
 135   nsresult rv;
 136
 137   rv = EnsureDirectoryExists(aDir);
 138   if (NS_FAILED(rv))
 139     return rv;
 140
 141   rv = EnsureDirectoryExists(aLocalDir);
 142   if (NS_FAILED(rv))
 143     return rv;
 144
 145   mProfileDir = aDir;
 146   mProfileLocalDir = aLocalDir;
 147   return NS_OK;
 148 }
 149
 150 NS_IMPL_QUERY_INTERFACE3(nsXREDirProvider,
 151                          nsIDirectoryServiceProvider,
 152                          nsIDirectoryServiceProvider2,
 153                          nsIProfileStartup)
 154
 155 NS_IMETHODIMP_(nsrefcnt)
 156 nsXREDirProvider::AddRef()
 157 {
 158   return 1;
 159 }
 160
 161 NS_IMETHODIMP_(nsrefcnt)
 162 nsXREDirProvider::Release()
 163 {
 164   return 0;
 165 }
 166
 167 NS_IMETHODIMP
 168 nsXREDirProvider::GetFile(const char* aProperty, PRBool* aPersistent,
 169                           nsIFile** aFile)
 170 {
 171   nsresult rv;
 172
 173   PRBool gettingProfile = PR_FALSE;
 174
 175   if (!strcmp(aProperty, NS_APP_USER_PROFILE_LOCAL_50_DIR)) {
 176     // If XRE_NotifyProfile hasn't been called, don't fall through to
 177     // mAppProvider on the profile keys.
 178     if (!mProfileNotified)
 179       return NS_ERROR_FAILURE;
 180
 181     if (mProfileLocalDir)
 182       return mProfileLocalDir->Clone(aFile);
 183
 184     if (mAppProvider)
 185       return mAppProvider->GetFile(aProperty, aPersistent, aFile);
 186
 187     // This falls through to the case below
 188     gettingProfile = PR_TRUE;
 189   }
 190   if (!strcmp(aProperty, NS_APP_USER_PROFILE_50_DIR) || gettingProfile) {
 191     if (!mProfileNotified)
 192       return NS_ERROR_FAILURE;
 193
 194     if (mProfileDir)
 195       return mProfileDir->Clone(aFile);
 196
 197     if (mAppProvider)
 198       return mAppProvider->GetFile(aProperty, aPersistent, aFile);
 199
 200     // If we don't succeed here, bail early so that we aren't reentrant
 201     // through the "GetProfileDir" call below.
 202     return NS_ERROR_FAILURE;
 203   }
 204
 205   if (mAppProvider) {
 206     rv = mAppProvider->GetFile(aProperty, aPersistent, aFile);
 207     if (NS_SUCCEEDED(rv) && *aFile)
 208       return rv;
 209   }
 210
 211   *aPersistent = PR_TRUE;
 212
 213   if (!strcmp(aProperty, NS_GRE_DIR)) {
 214     return mGREDir->Clone(aFile);
 215   }
 216   else if (!strcmp(aProperty, NS_OS_CURRENT_PROCESS_DIR) ||
 217       !strcmp(aProperty, NS_APP_INSTALL_CLEANUP_DIR)) {
 218     return GetAppDir()->Clone(aFile);
 219   }
 220
 221   rv = NS_ERROR_FAILURE;
 222   nsCOMPtr<nsIFile> file;
 223
 224   if (!strcmp(aProperty, NS_APP_PROFILE_DEFAULTS_50_DIR) ||
 225            !strcmp(aProperty, NS_APP_PROFILE_DEFAULTS_NLOC_50_DIR)) {
 226     return GetProfileDefaultsDir(aFile);
 227   }
 228   else if (!strcmp(aProperty, NS_APP_PREF_DEFAULTS_50_DIR))
 229   {
 230     // return the GRE default prefs directory here, and the app default prefs
 231     // directory (if applicable) in NS_APP_PREFS_DEFAULTS_DIR_LIST.
 232     rv = mGREDir->Clone(getter_AddRefs(file));
 233     if (NS_SUCCEEDED(rv)) {
 234       rv = file->AppendNative(NS_LITERAL_CSTRING("defaults"));
 235       if (NS_SUCCEEDED(rv))
 236         rv = file->AppendNative(NS_LITERAL_CSTRING("pref"));
 237     }
 238   }
 239   else if (!strcmp(aProperty, NS_APP_APPLICATION_REGISTRY_DIR) ||
 240            !strcmp(aProperty, XRE_USER_APP_DATA_DIR)) {
 241     rv = GetUserAppDataDirectory((nsILocalFile**)(nsIFile**) getter_AddRefs(file));
 242   }
 243   else if (!strcmp(aProperty, XRE_UPDATE_ROOT_DIR)) {
 244 #ifdef XP_WIN
 245     rv = GetUpdateRootDir(getter_AddRefs(file));
 246 #else
 247     // Only supported on Windows, so just immediately fail.
 248     return NS_ERROR_FAILURE;
 249 #endif
 250   }
 251   else if (!strcmp(aProperty, NS_APP_APPLICATION_REGISTRY_FILE)) {
 252     rv = GetUserAppDataDirectory((nsILocalFile**)(nsIFile**) getter_AddRefs(file));
 253     if (NS_SUCCEEDED(rv))
 254       rv = file->AppendNative(NS_LITERAL_CSTRING(APP_REGISTRY_NAME));
 255   }
 256   else if (!strcmp(aProperty, NS_APP_USER_PROFILES_ROOT_DIR)) {
 257     rv = GetUserAppDataDirectory((nsILocalFile**)(nsIFile**) getter_AddRefs(file));
 258
 259     if (NS_SUCCEEDED(rv)) {
 260 #if !defined(XP_UNIX) || defined(XP_MACOSX)
 261       rv = file->AppendNative(NS_LITERAL_CSTRING("Profiles"));
 262 #endif
 263
 264       // We must create the profile directory here if it does not exist.
 265       rv |= EnsureDirectoryExists(file);
 266     }
 267   }
 268   else if (!strcmp(aProperty, NS_APP_USER_PROFILES_LOCAL_ROOT_DIR)) {
 269     rv = GetUserLocalDataDirectory((nsILocalFile**)(nsIFile**) getter_AddRefs(file));
 270
 271     if (NS_SUCCEEDED(rv)) {
 272 #if !defined(XP_UNIX) || defined(XP_MACOSX)
 273       rv = file->AppendNative(NS_LITERAL_CSTRING("Profiles"));
 274 #endif
 275
 276       // We must create the profile directory here if it does not exist.
 277       rv |= EnsureDirectoryExists(file);
 278     }
 279   }
 280   else if (!strcmp(aProperty, XRE_EXECUTABLE_FILE) && gArgv[0]) {
 281     nsCOMPtr<nsILocalFile> lf;
 282     rv = XRE_GetBinaryPath(gArgv[0], getter_AddRefs(lf));
 283     if (NS_SUCCEEDED(rv))
 284       file = lf;
 285   }
 286   else if (!strcmp(aProperty, "resource:app")) {
 287     rv = GetAppDir()->Clone(getter_AddRefs(file));
 288   }
 289
 290   else if (!strcmp(aProperty, NS_APP_PROFILE_DIR_STARTUP) && mProfileDir) {
 291     return mProfileDir->Clone(aFile);
 292   }
 293   else if (!strcmp(aProperty, NS_APP_PROFILE_LOCAL_DIR_STARTUP)) {
 294     if (mProfileLocalDir)
 295       return mProfileLocalDir->Clone(aFile);
 296
 297     if (mProfileDir)
 298       return mProfileDir->Clone(aFile);
 299
 300     if (mAppProvider)
 301       return mAppProvider->GetFile(NS_APP_PROFILE_DIR_STARTUP, aPersistent,
 302                                    aFile);
 303   }
 304 #if defined(XP_UNIX) || defined(XP_MACOSX)
 305   else if (!strcmp(aProperty, XRE_SYS_LOCAL_EXTENSION_PARENT_DIR)) {
 306     return GetSystemExtensionsDirectory((nsILocalFile**)(nsIFile**) aFile);
 307   }
 308 #endif
 309 #if defined(XP_UNIX) && !defined(XP_MACOSX)
 310   else if (!strcmp(aProperty, XRE_SYS_SHARE_EXTENSION_PARENT_DIR)) {
 311     static const char *const sysLExtDir = "/usr/share/mozilla/extensions";
 312     return NS_NewNativeLocalFile(nsDependentCString(sysLExtDir),
 313                                  PR_FALSE, (nsILocalFile**)(nsIFile**) aFile);
 314   }
 315 #endif
 316   else if (!strcmp(aProperty, XRE_USER_SYS_EXTENSION_DIR)) {
 317     return GetSysUserExtensionsDirectory((nsILocalFile**)(nsIFile**) aFile);
 318   }
 319   else if (NS_SUCCEEDED(GetProfileStartupDir(getter_AddRefs(file)))) {
 320     // We need to allow component, xpt, and chrome registration to
 321     // occur prior to the profile-after-change notification.
 322     if (!strcmp(aProperty, NS_XPCOM_COMPONENT_REGISTRY_FILE)) {
 323       rv = file->AppendNative(NS_LITERAL_CSTRING("compreg.dat"));
 324     }
 325     else if (!strcmp(aProperty, NS_XPCOM_XPTI_REGISTRY_FILE)) {
 326       rv = file->AppendNative(NS_LITERAL_CSTRING("xpti.dat"));
 327     }
 328     else if (!strcmp(aProperty, NS_APP_USER_CHROME_DIR)) {
 329       rv = file->AppendNative(NS_LITERAL_CSTRING("chrome"));
 330     }
 331   }
 332
 333   if (NS_SUCCEEDED(rv) && file) {
 334     NS_ADDREF(*aFile = file);
 335     return NS_OK;
 336   }
 337
 338   PRBool ensureFilePermissions = PR_FALSE;
 339
 340   if (NS_SUCCEEDED(GetProfileDir(getter_AddRefs(file)))) {
 341     if (!strcmp(aProperty, NS_APP_PREFS_50_DIR)) {
 342       rv = NS_OK;
 343     }
 344     else if (!strcmp(aProperty, NS_APP_PREFS_50_FILE)) {
 345       rv = file->AppendNative(NS_LITERAL_CSTRING("prefs.js"));
 346     }
 347     else if (!strcmp(aProperty, NS_LOCALSTORE_UNSAFE_FILE)) {
 348       rv = file->AppendNative(NS_LITERAL_CSTRING("localstore.rdf"));
 349     }
 350     else if (!strcmp(aProperty, NS_APP_LOCALSTORE_50_FILE)) {
 351       if (gSafeMode) {
 352         rv = file->AppendNative(NS_LITERAL_CSTRING("localstore-safe.rdf"));
 353         file->Remove(PR_FALSE);
 354       }
 355       else {
 356         rv = file->AppendNative(NS_LITERAL_CSTRING("localstore.rdf"));
 357         EnsureProfileFileExists(file);
 358         ensureFilePermissions = PR_TRUE;
 359       }
 360     }
 361     else if (!strcmp(aProperty, NS_APP_HISTORY_50_FILE)) {
 362       rv = file->AppendNative(NS_LITERAL_CSTRING("history.dat"));
 363     }
 364     else if (!strcmp(aProperty, NS_APP_USER_MIMETYPES_50_FILE)) {
 365       rv = file->AppendNative(NS_LITERAL_CSTRING("mimeTypes.rdf"));
 366       EnsureProfileFileExists(file);
 367       ensureFilePermissions = PR_TRUE;
 368     }
 369     else if (!strcmp(aProperty, NS_APP_STORAGE_50_FILE)) {
 370       rv = file->AppendNative(NS_LITERAL_CSTRING("storage.sdb"));
 371     }
 372     else if (!strcmp(aProperty, NS_APP_DOWNLOADS_50_FILE)) {
 373       rv = file->AppendNative(NS_LITERAL_CSTRING("downloads.rdf"));
 374     }
 375     else if (!strcmp(aProperty, NS_APP_PREFS_OVERRIDE_DIR)) {
 376       rv = mProfileDir->Clone(getter_AddRefs(file));
 377       rv |= file->AppendNative(NS_LITERAL_CSTRING(PREF_OVERRIDE_DIRNAME));
 378       rv |= EnsureDirectoryExists(file);
 379     }
 380   }
 381   if (NS_FAILED(rv) || !file)
 382     return NS_ERROR_FAILURE;
 383
 384   if (ensureFilePermissions) {
 385     PRBool fileToEnsureExists;
 386     PRBool isWritable;
 387     if (NS_SUCCEEDED(file->Exists(&fileToEnsureExists)) && fileToEnsureExists
 388         && NS_SUCCEEDED(file->IsWritable(&isWritable)) && !isWritable) {
 389       PRUint32 permissions;
 390       if (NS_SUCCEEDED(file->GetPermissions(&permissions))) {
 391         rv = file->SetPermissions(permissions | 0600);
 392         NS_ASSERTION(NS_SUCCEEDED(rv), "failed to ensure file permissions");
 393       }
 394     }
 395   }
 396
 397   NS_ADDREF(*aFile = file);
 398   return NS_OK;
 399 }
 400
 401 static void
 402 LoadPlatformDirectory(nsIFile* aBundleDirectory,
 403                       nsCOMArray<nsIFile> &aDirectories)
 404 {
 405   nsCOMPtr<nsIFile> platformDir;
 406   nsresult rv = aBundleDirectory->Clone(getter_AddRefs(platformDir));
 407   if (NS_FAILED(rv))
 408     return;
 409
 410   platformDir->AppendNative(NS_LITERAL_CSTRING("platform"));
 411
 412 #ifdef TARGET_OS_ABI
 413   nsCOMPtr<nsIFile> platformABIDir;
 414   rv = platformDir->Clone(getter_AddRefs(platformABIDir));
 415   if (NS_FAILED(rv))
 416     return;
 417 #endif
 418
 419   platformDir->AppendNative(NS_LITERAL_CSTRING(OS_TARGET));
 420
 421   PRBool exists;
 422   if (NS_SUCCEEDED(platformDir->Exists(&exists)) && exists)
 423     aDirectories.AppendObject(platformDir);
 424
 425 #ifdef TARGET_OS_ABI
 426   platformABIDir->AppendNative(NS_LITERAL_CSTRING(TARGET_OS_ABI));
 427   if (NS_SUCCEEDED(platformABIDir->Exists(&exists)) && exists)
 428     aDirectories.AppendObject(platformABIDir);
 429 #endif
 430 }
 431
 432 static void
 433 LoadAppDirIntoArray(nsIFile* aXULAppDir,
 434                     const char *const *aAppendList,
 435                     nsCOMArray<nsIFile>& aDirectories)
 436 {
 437   if (!aXULAppDir)
 438     return;
 439
 440   nsCOMPtr<nsIFile> subdir;
 441   aXULAppDir->Clone(getter_AddRefs(subdir));
 442   if (!subdir)
 443     return;
 444
 445   for (; *aAppendList; ++aAppendList)
 446     subdir->AppendNative(nsDependentCString(*aAppendList));
 447
 448   PRBool exists;
 449   if (NS_SUCCEEDED(subdir->Exists(&exists)) && exists)
 450     aDirectories.AppendObject(subdir);
 451 }
 452
 453 static void
 454 LoadDirsIntoArray(nsCOMArray<nsIFile>& aSourceDirs,
 455                   const char *const* aAppendList,
 456                   nsCOMArray<nsIFile>& aDirectories)
 457 {
 458   nsCOMPtr<nsIFile> appended;
 459   PRBool exists;
 460
 461   for (PRInt32 i = 0; i < aSourceDirs.Count(); ++i) {
 462     aSourceDirs[i]->Clone(getter_AddRefs(appended));
 463     if (!appended)
 464       continue;
 465
 466     for (const char *const *a = aAppendList; *a; ++a)
 467       appended->AppendNative(nsDependentCString(*a));
 468
 469     if (NS_SUCCEEDED(appended->Exists(&exists)) && exists)
 470       aDirectories.AppendObject(appended);
 471   }
 472 }
 473
 474 static const char *const kAppendChromeManifests[] =
 475   { "chrome.manifest", nsnull };
 476
 477 NS_IMETHODIMP
 478 nsXREDirProvider::GetFiles(const char* aProperty, nsISimpleEnumerator** aResult)
 479 {
 480   nsresult rv;
 481
 482   nsCOMPtr<nsISimpleEnumerator> appEnum;
 483   nsCOMPtr<nsIDirectoryServiceProvider2>
 484     appP2(do_QueryInterface(mAppProvider));
 485   if (appP2) {
 486     rv = appP2->GetFiles(aProperty, getter_AddRefs(appEnum));
 487     if (NS_FAILED(rv)) {
 488       appEnum = nsnull;
 489     }
 490     else if (rv != NS_SUCCESS_AGGREGATE_RESULT) {
 491       NS_ADDREF(*aResult = appEnum);
 492       return NS_OK;
 493     }
 494   }
 495
 496   nsCOMPtr<nsISimpleEnumerator> xreEnum;
 497   rv = GetFilesInternal(aProperty, getter_AddRefs(xreEnum));
 498   if (NS_FAILED(rv)) {
 499     if (appEnum) {
 500       NS_ADDREF(*aResult = appEnum);
 501       return NS_SUCCESS_AGGREGATE_RESULT;
 502     }
 503
 504     return rv;
 505   }
 506
 507   rv = NS_NewUnionEnumerator(aResult, appEnum, xreEnum);
 508   if (NS_FAILED(rv))
 509     return rv;
 510
 511   return NS_SUCCESS_AGGREGATE_RESULT;
 512 }
 513
 514 static void
 515 LoadExtensionDirectories(nsINIParser &parser,
 516                          const char *aSection,
 517                          nsCOMArray<nsIFile> &aDirectories)
 518 {
 519   nsresult rv;
 520   PRInt32 i = 0;
 521   do {
 522     nsCAutoString buf("Extension");
 523     buf.AppendInt(i++);
 524
 525     nsCAutoString path;
 526     rv = parser.GetString(aSection, buf.get(), path);
 527     if (NS_FAILED(rv))
 528       return;
 529
 530     nsCOMPtr<nsILocalFile> dir = do_CreateInstance("@mozilla.org/file/local;1", &rv);
 531     if (NS_FAILED(rv))
 532       continue;
 533
 534     rv = dir->SetPersistentDescriptor(path);
 535     if (NS_FAILED(rv))
 536       continue;
 537
 538     aDirectories.AppendObject(dir);
 539     LoadPlatformDirectory(dir, aDirectories);
 540   }
 541   while (PR_TRUE);
 542 }
 543
 544 void
 545 nsXREDirProvider::LoadBundleDirectories()
 546 {
 547   if (mExtensionsLoaded)
 548     return;
 549
 550   mExtensionsLoaded = PR_TRUE;
 551
 552   // first load distribution/bundles
 553   if (mXULAppDir) {
 554     LoadPlatformDirectory(mXULAppDir, mAppBundleDirectories);
 555
 556     LoadAppBundleDirs();
 557   }
 558
 559   if (mProfileDir && !gSafeMode) {
 560     nsCOMPtr<nsIFile> extensionsINI;
 561     mProfileDir->Clone(getter_AddRefs(extensionsINI));
 562     if (!extensionsINI)
 563       return;
 564
 565     extensionsINI->AppendNative(NS_LITERAL_CSTRING("extensions.ini"));
 566
 567     nsCOMPtr<nsILocalFile> extensionsINILF =
 568       do_QueryInterface(extensionsINI);
 569     if (!extensionsINILF)
 570       return;
 571
 572     nsINIParser parser;
 573     nsresult rv = parser.Init(extensionsINILF);
 574     if (NS_FAILED(rv))
 575       return;
 576
 577     LoadExtensionDirectories(parser, "ExtensionDirs", mExtensionDirectories);
 578     LoadExtensionDirectories(parser, "ThemeDirs", mThemeDirectories);
 579   }
 580 }
 581
 582 void
 583 nsXREDirProvider::LoadAppBundleDirs()
 584 {
 585   if (!mXULAppDir)
 586     return;
 587
 588   nsCOMPtr<nsIFile> dir;
 589   nsresult rv = mXULAppDir->Clone(getter_AddRefs(dir));
 590   if (NS_FAILED(rv))
 591     return;
 592
 593   dir->AppendNative(NS_LITERAL_CSTRING("distribution"));
 594   dir->AppendNative(NS_LITERAL_CSTRING("bundles"));
 595
 596   PRBool exists;
 597   if (NS_FAILED(dir->Exists(&exists)) || !exists)
 598     return;
 599
 600   nsCOMPtr<nsISimpleEnumerator> e;
 601   rv = dir->GetDirectoryEntries(getter_AddRefs(e));
 602   if (NS_FAILED(rv))
 603     return;
 604
 605   nsCOMPtr<nsIDirectoryEnumerator> files = do_QueryInterface(e);
 606   if (!files)
 607     return;
 608
 609   nsCOMPtr<nsIFile> subdir;
 610   while (NS_SUCCEEDED(files->GetNextFile(getter_AddRefs(subdir))) && subdir) {
 611     mAppBundleDirectories.AppendObject(subdir);
 612     LoadPlatformDirectory(subdir, mAppBundleDirectories);
 613   }
 614 }
 615
 616 static const char *const kAppendPrefDir[] = { "defaults", "preferences", nsnull };
 617
 618 #ifdef DEBUG_bsmedberg
 619 static void
 620 DumpFileArray(const char *key,
 621               nsCOMArray<nsIFile> dirs)
 622 {
 623   fprintf(stderr, "nsXREDirProvider::GetFilesInternal(%s)\n", key);
 624
 625   nsCAutoString path;
 626   for (PRInt32 i = 0; i < dirs.Count(); ++i) {
 627     dirs[i]->GetNativePath(path);
 628     fprintf(stderr, "  %s\n", path.get());
 629   }
 630 }
 631 #endif // DEBUG_bsmedberg
 632
 633 nsresult
 634 nsXREDirProvider::GetFilesInternal(const char* aProperty,
 635                                    nsISimpleEnumerator** aResult)
 636 {
 637   nsresult rv = NS_OK;
 638   *aResult = nsnull;
 639
 640   if (!strcmp(aProperty, XRE_EXTENSIONS_DIR_LIST)) {
 641     nsCOMArray<nsIFile> directories;
 642
 643     static const char *const kAppendNothing[] = { nsnull };
 644
 645     LoadBundleDirectories();
 646     LoadDirsIntoArray(mAppBundleDirectories,
 647                       kAppendNothing, directories);
 648     LoadDirsIntoArray(mExtensionDirectories,
 649                       kAppendNothing, directories);
 650
 651     rv = NS_NewArrayEnumerator(aResult, directories);
 652   }
 653   else if (!strcmp(aProperty, NS_XPCOM_COMPONENT_DIR_LIST)) {
 654     static const char *const kAppendCompDir[] = { "components", nsnull };
 655     nsCOMArray<nsIFile> directories;
 656
 657     LoadBundleDirectories();
 658     LoadDirsIntoArray(mAppBundleDirectories,
 659                       kAppendCompDir, directories);
 660     LoadDirsIntoArray(mExtensionDirectories,
 661                       kAppendCompDir, directories);
 662
 663     rv = NS_NewArrayEnumerator(aResult, directories);
 664   }
 665   else if (!strcmp(aProperty, NS_APP_PREFS_DEFAULTS_DIR_LIST)) {
 666     nsCOMArray<nsIFile> directories;
 667
 668     LoadBundleDirectories();
 669
 670     LoadAppDirIntoArray(mXULAppDir, kAppendPrefDir, directories);
 671     LoadDirsIntoArray(mAppBundleDirectories,
 672                       kAppendPrefDir, directories);
 673
 674     rv = NS_NewArrayEnumerator(aResult, directories);
 675   }
 676   else if (!strcmp(aProperty, NS_EXT_PREFS_DEFAULTS_DIR_LIST)) {
 677     nsCOMArray<nsIFile> directories;
 678
 679     LoadBundleDirectories();
 680     LoadDirsIntoArray(mExtensionDirectories,
 681                       kAppendPrefDir, directories);
 682
 683     if (mProfileDir) {
 684       nsCOMPtr<nsIFile> overrideFile;
 685       mProfileDir->Clone(getter_AddRefs(overrideFile));
 686       overrideFile->AppendNative(NS_LITERAL_CSTRING(PREF_OVERRIDE_DIRNAME));
 687
 688       PRBool exists;
 689       if (NS_SUCCEEDED(overrideFile->Exists(&exists)) && exists)
 690         directories.AppendObject(overrideFile);
 691     }
 692
 693     rv = NS_NewArrayEnumerator(aResult, directories);
 694   }
 695   else if (!strcmp(aProperty, NS_CHROME_MANIFESTS_FILE_LIST)) {
 696     nsCOMArray<nsIFile> manifests;
 697
 698     nsCOMPtr<nsIFile> manifest;
 699     mGREDir->Clone(getter_AddRefs(manifest));
 700     manifest->AppendNative(NS_LITERAL_CSTRING("chrome"));
 701     manifests.AppendObject(manifest);
 702
 703     if (mXULAppDir) {
 704       nsCOMPtr<nsIFile> file;
 705       mXULAppDir->Clone(getter_AddRefs(file));
 706       file->AppendNative(NS_LITERAL_CSTRING("chrome"));
 707       PRBool exists;
 708       if (NS_SUCCEEDED(file->Exists(&exists)) && exists)
 709         manifests.AppendObject(file);
 710     }
 711
 712     LoadBundleDirectories();
 713     LoadDirsIntoArray(mAppBundleDirectories,
 714                       kAppendChromeManifests,
 715                       manifests);
 716     LoadDirsIntoArray(mExtensionDirectories,
 717                       kAppendChromeManifests,
 718                       manifests);
 719
 720     rv = NS_NewArrayEnumerator(aResult, manifests);
 721   }
 722   else if (!strcmp(aProperty, NS_SKIN_MANIFESTS_FILE_LIST)) {
 723     nsCOMArray<nsIFile> manifests;
 724
 725     LoadBundleDirectories();
 726     LoadDirsIntoArray(mThemeDirectories,
 727                       kAppendChromeManifests, manifests);
 728
 729     rv = NS_NewArrayEnumerator(aResult, manifests);
 730   }
 731   else if (!strcmp(aProperty, NS_APP_CHROME_DIR_LIST)) {
 732     // NS_APP_CHROME_DIR_LIST is only used to get default (native) icons
 733     // for OS window decoration.
 734
 735     static const char *const kAppendChromeDir[] = { "chrome", nsnull };
 736     nsCOMArray<nsIFile> directories;
 737     LoadBundleDirectories();
 738     LoadAppDirIntoArray(mXULAppDir,
 739                         kAppendChromeDir,
 740                         directories);
 741     LoadDirsIntoArray(mAppBundleDirectories,
 742                       kAppendChromeDir,
 743                       directories);
 744     LoadDirsIntoArray(mExtensionDirectories,
 745                       kAppendChromeDir,
 746                       directories);
 747
 748     rv = NS_NewArrayEnumerator(aResult, directories);
 749   }
 750   else if (!strcmp(aProperty, NS_APP_PLUGINS_DIR_LIST)) {
 751     static const char *const kAppendPlugins[] = { "plugins", nsnull };
 752     nsCOMArray<nsIFile> directories;
 753
 754     // The root dirserviceprovider does quite a bit for us: we're mainly
 755     // interested in xulapp and extension-provided plugins.
 756     LoadBundleDirectories();
 757     LoadDirsIntoArray(mAppBundleDirectories,
 758                       kAppendPlugins,
 759                       directories);
 760     LoadDirsIntoArray(mExtensionDirectories,
 761                       kAppendPlugins,
 762                       directories);
 763
 764     rv = NS_NewArrayEnumerator(aResult, directories);
 765     NS_ENSURE_SUCCESS(rv, rv);
 766
 767     rv = NS_SUCCESS_AGGREGATE_RESULT;
 768   }
 769   else
 770     rv = NS_ERROR_FAILURE;
 771
 772   return rv;
 773 }
 774
 775 NS_IMETHODIMP
 776 nsXREDirProvider::GetDirectory(nsIFile* *aResult)
 777 {
 778   NS_ENSURE_TRUE(mProfileDir, NS_ERROR_NOT_INITIALIZED);
 779
 780   return mProfileDir->Clone(aResult);
 781 }
 782
 783 NS_IMETHODIMP
 784 nsXREDirProvider::DoStartup()
 785 {
 786   if (!mProfileNotified) {
 787     nsCOMPtr<nsIObserverService> obsSvc
 788       (do_GetService("@mozilla.org/observer-service;1"));
 789     if (!obsSvc) return NS_ERROR_FAILURE;
 790
 791     mProfileNotified = PR_TRUE;
 792
 793     static const PRUnichar kStartup[] = {'s','t','a','r','t','u','p','\0'};
 794     obsSvc->NotifyObservers(nsnull, "profile-do-change", kStartup);
 795     obsSvc->NotifyObservers(nsnull, "profile-after-change", kStartup);
 796   }
 797   return NS_OK;
 798 }
 799
 800 class ProfileChangeStatusImpl : public nsIProfileChangeStatus
 801 {
 802 public:
 803   NS_DECL_ISUPPORTS
 804   NS_DECL_NSIPROFILECHANGESTATUS
 805   ProfileChangeStatusImpl() { }
 806 private:
 807   ~ProfileChangeStatusImpl() { }
 808 };
 809
 810 NS_IMPL_ISUPPORTS1(ProfileChangeStatusImpl, nsIProfileChangeStatus)
 811
 812 NS_IMETHODIMP
 813 ProfileChangeStatusImpl::VetoChange()
 814 {
 815   NS_ERROR("Can't veto change!");
 816   return NS_ERROR_FAILURE;
 817 }
 818
 819 NS_IMETHODIMP
 820 ProfileChangeStatusImpl::ChangeFailed()
 821 {
 822   NS_ERROR("Profile change cancellation.");
 823   return NS_ERROR_FAILURE;
 824 }
 825
 826 void
 827 nsXREDirProvider::DoShutdown()
 828 {
 829   if (mProfileNotified) {
 830     nsCOMPtr<nsIObserverService> obssvc
 831       (do_GetService("@mozilla.org/observer-service;1"));
 832     NS_ASSERTION(obssvc, "No observer service?");
 833     if (obssvc) {
 834       nsCOMPtr<nsIProfileChangeStatus> cs = new ProfileChangeStatusImpl();
 835       static const PRUnichar kShutdownPersist[] =
 836         {'s','h','u','t','d','o','w','n','-','p','e','r','s','i','s','t','\0'};
 837       obssvc->NotifyObservers(cs, "profile-change-net-teardown", kShutdownPersist);
 838       obssvc->NotifyObservers(cs, "profile-change-teardown", kShutdownPersist);
 839
 840       // Phase 2c: Now that things are torn down, force JS GC so that things which depend on
 841       // resources which are about to go away in "profile-before-change" are destroyed first.
 842       nsCOMPtr<nsIThreadJSContextStack> stack
 843         (do_GetService("@mozilla.org/js/xpc/ContextStack;1"));
 844       if (stack)
 845       {
 846         JSContext *cx = nsnull;
 847         stack->GetSafeJSContext(&cx);
 848         if (cx)
 849           ::JS_GC(cx);
 850       }
 851
 852       // Phase 3: Notify observers of a profile change
 853       obssvc->NotifyObservers(cs, "profile-before-change", kShutdownPersist);
 854     }
 855     mProfileNotified = PR_FALSE;
 856   }
 857 }
 858
 859 #ifdef XP_WIN
 860 static nsresult
 861 GetShellFolderPath(int folder, nsAString& _retval)
 862 {
 863   LPITEMIDLIST pItemIDList = NULL;
 864
 865   PRUnichar* buf;
 866   PRUint32 bufLength = _retval.GetMutableData(&buf, MAXPATHLEN);
 867   NS_ENSURE_TRUE(bufLength >= MAXPATHLEN, NS_ERROR_OUT_OF_MEMORY);
 868
 869   nsresult rv;
 870   if (SUCCEEDED(SHGetSpecialFolderLocation(NULL, folder, &pItemIDList)) &&
 871       SHGetPathFromIDListW(pItemIDList, buf)) {
 872     // We're going to use wcslen (wcsnlen not available in msvc7.1) so make
 873     // sure to null terminate.
 874     buf[bufLength - 1] = L'\0';
 875     _retval.SetLength(wcslen(buf));
 876     rv = NS_OK;
 877   } else {
 878     _retval.SetLength(0);
 879     rv = NS_ERROR_NOT_AVAILABLE;
 880   }
 881
 882   CoTaskMemFree(pItemIDList);
 883
 884   return rv;
 885 }
 886
 887 nsresult
 888 nsXREDirProvider::GetUpdateRootDir(nsIFile* *aResult)
 889 {
 890   nsCOMPtr<nsIFile> appDir = GetAppDir();
 891
 892   nsAutoString appPath;
 893   nsresult rv = appDir->GetPath(appPath);
 894   NS_ENSURE_SUCCESS(rv, rv);
 895
 896   // AppDir may be a short path. Convert to long path to make sure
 897   // the consistency of the update folder location
 898   nsString longPath;
 899   PRUnichar* buf;
 900
 901   PRUint32 bufLength = longPath.GetMutableData(&buf, MAXPATHLEN);
 902   NS_ENSURE_TRUE(bufLength >= MAXPATHLEN, NS_ERROR_OUT_OF_MEMORY);
 903
 904   DWORD len = GetLongPathNameW(appPath.get(), buf, bufLength);
 905
 906   // Failing GetLongPathName() is not fatal.
 907   if (len <= 0 || len >= bufLength)
 908     longPath.Assign(appPath);
 909   else
 910     longPath.SetLength(len);
 911
 912   // Use <UserLocalDataDir>\updates\<relative path to app dir from
 913   // Program Files> if app dir is under Program Files to avoid the
 914   // folder virtualization mess on Windows Vista
 915   nsAutoString programFiles;
 916   rv = GetShellFolderPath(CSIDL_PROGRAM_FILES, programFiles);
 917   NS_ENSURE_SUCCESS(rv, rv);
 918
 919   programFiles.AppendLiteral("\\");
 920   PRUint32 programFilesLen = programFiles.Length();
 921
 922   if (longPath.Length() < programFilesLen)
 923     return NS_ERROR_FAILURE;
 924
 925   if (_wcsnicmp(programFiles.get(), longPath.get(), programFilesLen) != 0)
 926     return NS_ERROR_FAILURE;
 927
 928   nsCOMPtr<nsILocalFile> updRoot;
 929   rv = GetUserLocalDataDirectory(getter_AddRefs(updRoot));
 930   NS_ENSURE_SUCCESS(rv, rv);
 931
 932   rv = updRoot->AppendRelativePath(Substring(longPath, programFilesLen));
 933   NS_ENSURE_SUCCESS(rv, rv);
 934
 935   NS_ADDREF(*aResult = updRoot);
 936   return NS_OK;
 937 }
 938 #endif
 939
 940 nsresult
 941 nsXREDirProvider::GetProfileStartupDir(nsIFile* *aResult)
 942 {
 943   if (mProfileDir)
 944     return mProfileDir->Clone(aResult);
 945
 946   if (mAppProvider) {
 947     nsCOMPtr<nsIFile> needsclone;
 948     PRBool dummy;
 949     nsresult rv = mAppProvider->GetFile(NS_APP_PROFILE_DIR_STARTUP,
 950                                         &dummy,
 951                                         getter_AddRefs(needsclone));
 952     if (NS_SUCCEEDED(rv))
 953       return needsclone->Clone(aResult);
 954   }
 955
 956   return NS_ERROR_FAILURE;
 957 }
 958
 959 nsresult
 960 nsXREDirProvider::GetProfileDir(nsIFile* *aResult)
 961 {
 962   if (mProfileDir) {
 963     if (!mProfileNotified)
 964       return NS_ERROR_FAILURE;
 965
 966     return mProfileDir->Clone(aResult);
 967   }
 968
 969   if (mAppProvider) {
 970     nsCOMPtr<nsIFile> needsclone;
 971     PRBool dummy;
 972     nsresult rv = mAppProvider->GetFile(NS_APP_USER_PROFILE_50_DIR,
 973                                         &dummy,
 974                                         getter_AddRefs(needsclone));
 975     if (NS_SUCCEEDED(rv))
 976       return needsclone->Clone(aResult);
 977   }
 978
 979   return NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR, aResult);
 980 }
 981
 982 nsresult
 983 nsXREDirProvider::GetUserDataDirectoryHome(nsILocalFile** aFile, PRBool aLocal)
 984 {
 985   if (!gAppData)
 986     return NS_ERROR_FAILURE;
 987
 988   // Copied from nsAppFileLocationProvider (more or less)
 989   nsresult rv;
 990   nsCOMPtr<nsILocalFile> localDir;
 991
 992 #if defined(XP_MACOSX)
 993   FSRef fsRef;
 994   OSType folderType;
 995   if (aLocal) {
 996     folderType = kCachedDataFolderType;
 997   } else {
 998 #ifdef MOZ_THUNDERBIRD
 999     folderType = kDomainLibraryFolderType;
1000 #else
1001     folderType = kApplicationSupportFolderType;
1002 #endif
1003   }
1004   OSErr err = ::FSFindFolder(kUserDomain, folderType, kCreateFolder, &fsRef);
1005   NS_ENSURE_FALSE(err, NS_ERROR_FAILURE);
1006
1007   rv = NS_NewNativeLocalFile(EmptyCString(), PR_TRUE, getter_AddRefs(localDir));
1008   NS_ENSURE_SUCCESS(rv, rv);
1009
1010   nsCOMPtr<nsILocalFileMac> dirFileMac = do_QueryInterface(localDir);
1011   NS_ENSURE_TRUE(dirFileMac, NS_ERROR_UNEXPECTED);
1012
1013   rv = dirFileMac->InitWithFSRef(&fsRef);
1014   NS_ENSURE_SUCCESS(rv, rv);
1015
1016   localDir = do_QueryInterface(dirFileMac, &rv);
1017 #elif defined(XP_WIN)
1018   nsString path;
1019   if (aLocal)
1020     rv = GetShellFolderPath(CSIDL_LOCAL_APPDATA, path);
1021   if (!aLocal || NS_FAILED(rv))
1022     rv = GetShellFolderPath(CSIDL_APPDATA, path);
1023   NS_ENSURE_SUCCESS(rv, rv);
1024
1025   rv = NS_NewLocalFile(path, PR_TRUE, getter_AddRefs(localDir));
1026 #elif defined(XP_OS2)
1027 #if 0 /* For OS/2 we want to always use MOZILLA_HOME */
1028   // we want an environment variable of the form
1029   // FIREFOX_HOME, etc
1030   nsDependentCString envVar(nsDependentCString(gAppData->name));
1031   envVar.Append("_HOME");
1032   char *pHome = getenv(envVar.get());
1033 #endif
1034   char *pHome = getenv("MOZILLA_HOME");
1035   if (pHome && *pHome) {
1036     rv = NS_NewNativeLocalFile(nsDependentCString(pHome), PR_TRUE,
1037                                getter_AddRefs(localDir));
1038   } else {
1039     PPIB ppib;
1040     PTIB ptib;
1041     char appDir[CCHMAXPATH];
1042
1043     DosGetInfoBlocks(&ptib, &ppib);
1044     DosQueryModuleName(ppib->pib_hmte, CCHMAXPATH, appDir);
1045     *strrchr(appDir, '\\') = '\0';
1046     rv = NS_NewNativeLocalFile(nsDependentCString(appDir), PR_TRUE, getter_AddRefs(localDir));
1047   }
1048 #elif defined(XP_BEOS)
1049   char appDir[MAXPATHLEN];
1050   if (find_directory(B_USER_SETTINGS_DIRECTORY, NULL, true, appDir, MAXPATHLEN))
1051     return NS_ERROR_FAILURE;
1052
1053   int len = strlen(appDir);
1054   appDir[len]   = '/';
1055   appDir[len+1] = '\0';
1056
1057   rv = NS_NewNativeLocalFile(nsDependentCString(appDir), PR_TRUE,
1058                              getter_AddRefs(localDir));
1059 #elif defined(XP_UNIX)
1060   const char* homeDir = getenv("HOME");
1061   if (!homeDir || !*homeDir)
1062     return NS_ERROR_FAILURE;
1063
1064   rv = NS_NewNativeLocalFile(nsDependentCString(homeDir), PR_TRUE,
1065                              getter_AddRefs(localDir));
1066 #else
1067 #error "Don't know how to get product dir on your platform"
1068 #endif
1069
1070   NS_IF_ADDREF(*aFile = localDir);
1071   return rv;
1072 }
1073
1074 nsresult
1075 nsXREDirProvider::GetSysUserExtensionsDirectory(nsILocalFile** aFile)
1076 {
1077   nsCOMPtr<nsILocalFile> localDir;
1078   nsresult rv = GetUserDataDirectoryHome(getter_AddRefs(localDir), PR_FALSE);
1079   NS_ENSURE_SUCCESS(rv, rv);
1080
1081   rv = AppendSysUserExtensionPath(localDir);
1082   NS_ENSURE_SUCCESS(rv, rv);
1083
1084   rv = EnsureDirectoryExists(localDir);
1085   NS_ENSURE_SUCCESS(rv, rv);
1086
1087   NS_ADDREF(*aFile = localDir);
1088   return NS_OK;
1089 }
1090
1091 #if defined(XP_UNIX) || defined(XP_MACOSX)
1092 nsresult
1093 nsXREDirProvider::GetSystemExtensionsDirectory(nsILocalFile** aFile)
1094 {
1095   nsresult rv;
1096   nsCOMPtr<nsILocalFile> localDir;
1097 #if defined(XP_MACOSX)
1098   FSRef fsRef;
1099   OSErr err = ::FSFindFolder(kOnSystemDisk, kApplicationSupportFolderType, kCreateFolder, &fsRef);
1100   NS_ENSURE_FALSE(err, NS_ERROR_FAILURE);
1101
1102   rv = NS_NewNativeLocalFile(EmptyCString(), PR_TRUE, getter_AddRefs(localDir));
1103   NS_ENSURE_SUCCESS(rv, rv);
1104
1105   nsCOMPtr<nsILocalFileMac> dirFileMac = do_QueryInterface(localDir);
1106   NS_ENSURE_TRUE(dirFileMac, NS_ERROR_UNEXPECTED);
1107
1108   rv = dirFileMac->InitWithFSRef(&fsRef);
1109   NS_ENSURE_SUCCESS(rv, rv);
1110
1111   localDir = do_QueryInterface(dirFileMac, &rv);
1112
1113   static const char* const sXR = "Mozilla";
1114   rv = localDir->AppendNative(nsDependentCString(sXR));
1115   NS_ENSURE_SUCCESS(rv, rv);
1116
1117   static const char* const sExtensions = "Extensions";
1118   rv = localDir->AppendNative(nsDependentCString(sExtensions));
1119   NS_ENSURE_SUCCESS(rv, rv);
1120 #elif defined(XP_UNIX)
1121   static const char *const sysSExtDir =
1122 #ifdef HAVE_USR_LIB64_DIR
1123     "/usr/lib64/mozilla/extensions";
1124 #else
1125     "/usr/lib/mozilla/extensions";
1126 #endif
1127
1128   rv = NS_NewNativeLocalFile(nsDependentCString(sysSExtDir), PR_FALSE,
1129                              getter_AddRefs(localDir));
1130   NS_ENSURE_SUCCESS(rv, rv);
1131 #endif
1132
1133   rv = EnsureDirectoryExists(localDir);
1134   NS_ENSURE_SUCCESS(rv, rv);
1135
1136   NS_ADDREF(*aFile = localDir);
1137   return NS_OK;
1138 }
1139 #endif
1140
1141 nsresult
1142 nsXREDirProvider::GetUserDataDirectory(nsILocalFile** aFile, PRBool aLocal)
1143 {
1144   nsCOMPtr<nsILocalFile> localDir;
1145   nsresult rv = GetUserDataDirectoryHome(getter_AddRefs(localDir), aLocal);
1146   NS_ENSURE_SUCCESS(rv, rv);
1147
1148   rv = AppendProfilePath(localDir);
1149   NS_ENSURE_SUCCESS(rv, rv);
1150
1151 #ifdef DEBUG_jungshik
1152   nsCAutoString cwd;
1153   localDir->GetNativePath(cwd);
1154   printf("nsXREDirProvider::GetUserDataDirectory: %s\n", cwd.get());
1155 #endif
1156   rv = EnsureDirectoryExists(localDir);
1157   NS_ENSURE_SUCCESS(rv, rv);
1158
1159   NS_ADDREF(*aFile = localDir);
1160   return NS_OK;
1161 }
1162
1163 nsresult
1164 nsXREDirProvider::EnsureDirectoryExists(nsIFile* aDirectory)
1165 {
1166   PRBool exists;
1167   nsresult rv = aDirectory->Exists(&exists);
1168   NS_ENSURE_SUCCESS(rv, rv);
1169 #ifdef DEBUG_jungshik
1170   if (!exists) {
1171     nsCAutoString cwd;
1172     aDirectory->GetNativePath(cwd);
1173     printf("nsXREDirProvider::EnsureDirectoryExists: %s does not\n", cwd.get());
1174   }
1175 #endif
1176   if (!exists)
1177     rv = aDirectory->Create(nsIFile::DIRECTORY_TYPE, 0700);
1178 #ifdef DEBUG_jungshik
1179   if (NS_FAILED(rv))
1180     NS_WARNING("nsXREDirProvider::EnsureDirectoryExists: create failed");
1181 #endif
1182
1183   return rv;
1184 }
1185
1186 void
1187 nsXREDirProvider::EnsureProfileFileExists(nsIFile *aFile)
1188 {
1189   nsresult rv;
1190   PRBool exists;
1191
1192   rv = aFile->Exists(&exists);
1193   if (NS_FAILED(rv) || exists) return;
1194
1195   nsCAutoString leafName;
1196   rv = aFile->GetNativeLeafName(leafName);
1197   if (NS_FAILED(rv)) return;
1198
1199   nsCOMPtr<nsIFile> defaultsFile;
1200   rv = GetProfileDefaultsDir(getter_AddRefs(defaultsFile));
1201   if (NS_FAILED(rv)) return;
1202
1203   rv = defaultsFile->AppendNative(leafName);
1204   if (NS_FAILED(rv)) return;
1205
1206   defaultsFile->CopyToNative(mProfileDir, EmptyCString());
1207 }
1208
1209 nsresult
1210 nsXREDirProvider::GetProfileDefaultsDir(nsIFile* *aResult)
1211 {
1212   NS_ASSERTION(mGREDir, "nsXREDirProvider not initialized.");
1213   NS_PRECONDITION(aResult, "Null out-param");
1214
1215   nsresult rv;
1216   nsCOMPtr<nsIFile> defaultsDir;
1217
1218   rv = GetAppDir()->Clone(getter_AddRefs(defaultsDir));
1219   NS_ENSURE_SUCCESS(rv, rv);
1220
1221   rv = defaultsDir->AppendNative(NS_LITERAL_CSTRING("defaults"));
1222   NS_ENSURE_SUCCESS(rv, rv);
1223
1224   rv = defaultsDir->AppendNative(NS_LITERAL_CSTRING("profile"));
1225   NS_ENSURE_SUCCESS(rv, rv);
1226
1227   NS_ADDREF(*aResult = defaultsDir);
1228   return NS_OK;
1229 }
1230
1231 nsresult
1232 nsXREDirProvider::AppendSysUserExtensionPath(nsIFile* aFile)
1233 {
1234   NS_ASSERTION(aFile, "Null pointer!");
1235
1236   nsresult rv;
1237
1238 #if defined (XP_MACOSX) || defined(XP_WIN) || defined(XP_OS2) || defined(XP_BEOS)
1239
1240   static const char* const sXR = "Mozilla";
1241   rv = aFile->AppendNative(nsDependentCString(sXR));
1242   NS_ENSURE_SUCCESS(rv, rv);
1243
1244   static const char* const sExtensions = "Extensions";
1245   rv = aFile->AppendNative(nsDependentCString(sExtensions));
1246   NS_ENSURE_SUCCESS(rv, rv);
1247
1248 #elif defined(XP_UNIX)
1249
1250   static const char* const sXR = ".mozilla";
1251   rv = aFile->AppendNative(nsDependentCString(sXR));
1252   NS_ENSURE_SUCCESS(rv, rv);
1253
1254   static const char* const sExtensions = "extensions";
1255   rv = aFile->AppendNative(nsDependentCString(sExtensions));
1256   NS_ENSURE_SUCCESS(rv, rv);
1257
1258 #else
1259 #error "Don't know how to get XRE user extension path on your platform"
1260 #endif
1261   return NS_OK;
1262 }
1263
1264
1265 nsresult
1266 nsXREDirProvider::AppendProfilePath(nsIFile* aFile)
1267 {
1268   NS_ASSERTION(aFile, "Null pointer!");
1269
1270   nsresult rv;
1271
1272 #if defined (XP_MACOSX)
1273   if (gAppData->profile) {
1274     rv = AppendProfileString(aFile, gAppData->profile);
1275   }
1276   else {
1277     // Note that MacOS ignores the vendor when creating the profile hierarchy -
1278     // all application preferences directories live alongside one another in
1279     // ~/Library/Application Support/
1280     rv = aFile->AppendNative(nsDependentCString(gAppData->name));
1281   }
1282   NS_ENSURE_SUCCESS(rv, rv);
1283
1284 #elif defined(XP_WIN) || defined(XP_OS2) || defined(XP_BEOS)
1285   if (gAppData->profile) {
1286     rv = AppendProfileString(aFile, gAppData->profile);
1287   }
1288   else {
1289     if (gAppData->vendor) {
1290       rv = aFile->AppendNative(nsDependentCString(gAppData->vendor));
1291       NS_ENSURE_SUCCESS(rv, rv);
1292     }
1293     rv = aFile->AppendNative(nsDependentCString(gAppData->name));
1294   }
1295   NS_ENSURE_SUCCESS(rv, rv);
1296
1297 #elif defined(XP_UNIX)
1298   // Make it hidden (i.e. using the ".")
1299   nsCAutoString folder(".");
1300
1301   if (gAppData->profile) {
1302     // Skip any leading path characters
1303     const char* profileStart = gAppData->profile;
1304     while (*profileStart == '/' || *profileStart == '\\')
1305       profileStart++;
1306
1307     // On the off chance that someone wanted their folder to be hidden don't
1308     // let it become ".."
1309     if (*profileStart == '.')
1310       profileStart++;
1311
1312     folder.Append(profileStart);
1313     ToLowerCase(folder);
1314
1315     rv = AppendProfileString(aFile, folder.BeginReading());
1316   }
1317   else {
1318     if (gAppData->vendor) {
1319       folder.Append(gAppData->vendor);
1320       ToLowerCase(folder);
1321
1322       rv = aFile->AppendNative(folder);
1323       NS_ENSURE_SUCCESS(rv, rv);
1324
1325       folder.Truncate();
1326     }
1327
1328     folder.Append(gAppData->name);
1329     ToLowerCase(folder);
1330
1331     rv = aFile->AppendNative(folder);
1332   }
1333   NS_ENSURE_SUCCESS(rv, rv);
1334
1335 #else
1336 #error "Don't know how to get profile path on your platform"
1337 #endif
1338   return NS_OK;
1339 }
1340
1341 nsresult
1342 nsXREDirProvider::AppendProfileString(nsIFile* aFile, const char* aPath)
1343 {
1344   NS_ASSERTION(aFile, "Null file!");
1345   NS_ASSERTION(aPath, "Null path!");
1346
1347   nsCAutoString pathDup(aPath);
1348
1349   char* path = pathDup.BeginWriting();
1350
1351   nsresult rv;
1352   char* subdir;
1353   while ((subdir = NS_strtok("/\\", &path))) {
1354     rv = aFile->AppendNative(nsDependentCString(subdir));
1355     NS_ENSURE_SUCCESS(rv, rv);
1356   }
1357
1358   return NS_OK;
1359 }