The Tor Browser: toolkit/xre/nsXREDirProvider.cpp@129ffea94266 (annotated)

toolkit/xre/nsXREDirProvider.cpp@129ffea94266 (annotated)

toolkit/xre/nsXREDirProvider.cpp

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include "nsAppRunner.h"
 #include "nsToolkitCompsCID.h"
 #include "nsXREDirProvider.h"
 #include "jsapi.h"
 #include "nsIJSRuntimeService.h"
 #include "nsIAppStartup.h"
 #include "nsIDirectoryEnumerator.h"
 #include "nsIFile.h"
 #include "nsIObserver.h"
 #include "nsIObserverService.h"
 #include "nsISimpleEnumerator.h"
 #include "nsIToolkitChromeRegistry.h"
 #include "nsAppDirectoryServiceDefs.h"
 #include "nsDirectoryServiceDefs.h"
 #include "nsDirectoryServiceUtils.h"
 #include "nsXULAppAPI.h"
 #include "nsCategoryManagerUtils.h"
 #include "nsINIParser.h"
 #include "nsDependentString.h"
 #include "nsCOMArray.h"
 #include "nsArrayEnumerator.h"
 #include "nsEnumeratorUtils.h"
 #include "nsReadableUtils.h"
 #include "nsXPCOMPrivate.h"  // for XPCOM_FILE_PATH_SEPARATOR
 #include "mozilla/Services.h"
 #include "mozilla/Omnijar.h"
 #include "mozilla/Preferences.h"
 #include "mozilla/Telemetry.h"
 #include <stdlib.h>
 #ifdef XP_WIN
 #include <windows.h>
 #include <shlobj.h>
 #endif
 #ifdef XP_MACOSX
 #include "nsILocalFileMac.h"
 // for chflags()
 #include <sys/stat.h>
 #include <unistd.h>
 #endif
 #ifdef XP_UNIX
 #include <ctype.h>
 #endif
 #if defined(XP_MACOSX)
 #define APP_REGISTRY_NAME "Application Registry"
 #elif defined(XP_WIN)
 #define APP_REGISTRY_NAME "registry.dat"
 #else
 #define APP_REGISTRY_NAME "appreg"
 #endif
 #define PREF_OVERRIDE_DIRNAME "preferences"
 static already_AddRefed<nsIFile>
 CloneAndAppend(nsIFile* aFile, const char* name)
 {
   nsCOMPtr<nsIFile> file;
   aFile->Clone(getter_AddRefs(file));
   file->AppendNative(nsDependentCString(name));
   return file.forget();
 }
 nsXREDirProvider* gDirServiceProvider = nullptr;
 nsXREDirProvider::nsXREDirProvider() :
   mProfileNotified(false)
 {
   gDirServiceProvider = this;
 }
 nsXREDirProvider::~nsXREDirProvider()
 {
   gDirServiceProvider = nullptr;
 }
 nsXREDirProvider*
 nsXREDirProvider::GetSingleton()
 {
   return gDirServiceProvider;
 }
 nsresult
 nsXREDirProvider::Initialize(nsIFile *aXULAppDir,
                              nsIFile *aGREDir,
                              nsIDirectoryServiceProvider* aAppProvider)
 {
   NS_ENSURE_ARG(aXULAppDir);
   NS_ENSURE_ARG(aGREDir);
   mAppProvider = aAppProvider;
   mXULAppDir = aXULAppDir;
   mGREDir = aGREDir;
   if (!mProfileDir) {
     nsCOMPtr<nsIDirectoryServiceProvider> app(do_QueryInterface(mAppProvider));
     if (app) {
       bool per = false;
       app->GetFile(NS_APP_USER_PROFILE_50_DIR, &per, getter_AddRefs(mProfileDir));
       NS_ASSERTION(per, "NS_APP_USER_PROFILE_50_DIR must be persistent!");
       NS_ASSERTION(mProfileDir, "NS_APP_USER_PROFILE_50_DIR not defined! This shouldn't happen!");
     }
   }
   LoadAppBundleDirs();
   return NS_OK;
 }
 nsresult
 nsXREDirProvider::SetProfile(nsIFile* aDir, nsIFile* aLocalDir)
 {
   NS_ASSERTION(aDir && aLocalDir, "We don't support no-profile apps yet!");
   nsresult rv;
   rv = EnsureDirectoryExists(aDir);
   if (NS_FAILED(rv))
     return rv;
   rv = EnsureDirectoryExists(aLocalDir);
   if (NS_FAILED(rv))
     return rv;
 #ifdef XP_MACOSX
   bool same;
   if (NS_SUCCEEDED(aDir->Equals(aLocalDir, &same)) && !same) {
     // Ensure that the cache directory is not indexed by Spotlight
     // (bug 718910).  At least on OS X, the cache directory (under
     // ~/Library/Caches/) is always the "local" user profile
     // directory.  This is confusing, since *both* user profile
     // directories are "local" (they both exist under the user's
     // home directory).  But this usage dates back at least as far
     // as the patch for bug 291033, where "local" seems to mean
     // "suitable for temporary storage".  Don't hide the cache
     // directory if by some chance it and the "non-local" profile
     // directory are the same -- there are bad side effects from
     // hiding a profile directory under /Library/Application Support/
     // (see bug 801883).
     nsAutoCString cacheDir;
     if (NS_SUCCEEDED(aLocalDir->GetNativePath(cacheDir))) {
       if (chflags(cacheDir.get(), UF_HIDDEN)) {
         NS_WARNING("Failed to set Cache directory to HIDDEN.");
       }
     }
   }
 #endif
   mProfileDir = aDir;
   mProfileLocalDir = aLocalDir;
   return NS_OK;
 }
 NS_IMPL_QUERY_INTERFACE(nsXREDirProvider,
                         nsIDirectoryServiceProvider,
                         nsIDirectoryServiceProvider2,
                         nsIProfileStartup)
 NS_IMETHODIMP_(MozExternalRefCountType)
 nsXREDirProvider::AddRef()
 {
   return 1;
 }
 NS_IMETHODIMP_(MozExternalRefCountType)
 nsXREDirProvider::Release()
 {
   return 0;
 }
 nsresult
 nsXREDirProvider::GetUserProfilesRootDir(nsIFile** aResult,
                                          const nsACString* aProfileName,
                                          const nsACString* aAppName,
                                          const nsACString* aVendorName)
 {
   nsCOMPtr<nsIFile> file;
   nsresult rv = GetUserDataDirectory(getter_AddRefs(file),
                                      false,
                                      aProfileName, aAppName, aVendorName);
   if (NS_SUCCEEDED(rv)) {
     // We must create the profile directory here if it does not exist.
     nsresult tmp = EnsureDirectoryExists(file);
     if (NS_FAILED(tmp)) {
       rv = tmp;
     }
   }
   file.swap(*aResult);
   return rv;
 }
 nsresult
 nsXREDirProvider::GetUserProfilesLocalDir(nsIFile** aResult,
                                           const nsACString* aProfileName,
                                           const nsACString* aAppName,
                                           const nsACString* aVendorName)
 {
   nsCOMPtr<nsIFile> file;
   nsresult rv = GetUserDataDirectory(getter_AddRefs(file),
                                      true,
                                      aProfileName, aAppName, aVendorName);
   if (NS_SUCCEEDED(rv)) {
     // We must create the profile directory here if it does not exist.
     nsresult tmp = EnsureDirectoryExists(file);
     if (NS_FAILED(tmp)) {
       rv = tmp;
     }
   }
   file.swap(*aResult);
   return NS_OK;
 }
 NS_IMETHODIMP
 nsXREDirProvider::GetFile(const char* aProperty, bool* aPersistent,
 			  nsIFile** aFile)
 {
   nsresult rv;
   bool gettingProfile = false;
   if (!strcmp(aProperty, NS_APP_USER_PROFILE_LOCAL_50_DIR)) {
     // If XRE_NotifyProfile hasn't been called, don't fall through to
     // mAppProvider on the profile keys.
     if (!mProfileNotified)
       return NS_ERROR_FAILURE;
     if (mProfileLocalDir)
       return mProfileLocalDir->Clone(aFile);
     if (mAppProvider)
       return mAppProvider->GetFile(aProperty, aPersistent, aFile);
     // This falls through to the case below
     gettingProfile = true;
   }
   if (!strcmp(aProperty, NS_APP_USER_PROFILE_50_DIR) || gettingProfile) {
     if (!mProfileNotified)
       return NS_ERROR_FAILURE;
     if (mProfileDir)
       return mProfileDir->Clone(aFile);
     if (mAppProvider)
       return mAppProvider->GetFile(aProperty, aPersistent, aFile);
     // If we don't succeed here, bail early so that we aren't reentrant
     // through the "GetProfileDir" call below.
     return NS_ERROR_FAILURE;
   }
   if (mAppProvider) {
     rv = mAppProvider->GetFile(aProperty, aPersistent, aFile);
     if (NS_SUCCEEDED(rv) && *aFile)
       return rv;
   }
   *aPersistent = true;
   if (!strcmp(aProperty, NS_GRE_DIR)) {
     return mGREDir->Clone(aFile);
   }
   else if (!strcmp(aProperty, NS_OS_CURRENT_PROCESS_DIR) ||
       !strcmp(aProperty, NS_APP_INSTALL_CLEANUP_DIR)) {
     return GetAppDir()->Clone(aFile);
   }
   rv = NS_ERROR_FAILURE;
   nsCOMPtr<nsIFile> file;
   if (!strcmp(aProperty, NS_APP_PROFILE_DEFAULTS_50_DIR) ||
            !strcmp(aProperty, NS_APP_PROFILE_DEFAULTS_NLOC_50_DIR)) {
     return GetProfileDefaultsDir(aFile);
   }
   else if (!strcmp(aProperty, NS_APP_PREF_DEFAULTS_50_DIR))
   {
     // return the GRE default prefs directory here, and the app default prefs
     // directory (if applicable) in NS_APP_PREFS_DEFAULTS_DIR_LIST.
     rv = mGREDir->Clone(getter_AddRefs(file));
     if (NS_SUCCEEDED(rv)) {
       rv = file->AppendNative(NS_LITERAL_CSTRING("defaults"));
       if (NS_SUCCEEDED(rv))
         rv = file->AppendNative(NS_LITERAL_CSTRING("pref"));
     }
   }
   else if (!strcmp(aProperty, NS_APP_APPLICATION_REGISTRY_DIR) ||
            !strcmp(aProperty, XRE_USER_APP_DATA_DIR)) {
     rv = GetUserAppDataDirectory(getter_AddRefs(file));
   }
   else if (!strcmp(aProperty, XRE_UPDATE_ROOT_DIR)) {
     rv = GetUpdateRootDir(getter_AddRefs(file));
   }
   else if (!strcmp(aProperty, NS_APP_APPLICATION_REGISTRY_FILE)) {
     rv = GetUserAppDataDirectory(getter_AddRefs(file));
     if (NS_SUCCEEDED(rv))
       rv = file->AppendNative(NS_LITERAL_CSTRING(APP_REGISTRY_NAME));
   }
   else if (!strcmp(aProperty, NS_APP_USER_PROFILES_ROOT_DIR)) {
     rv = GetUserProfilesRootDir(getter_AddRefs(file), nullptr, nullptr, nullptr);
   }
   else if (!strcmp(aProperty, NS_APP_USER_PROFILES_LOCAL_ROOT_DIR)) {
     rv = GetUserProfilesLocalDir(getter_AddRefs(file), nullptr, nullptr, nullptr);
   }
   else if (!strcmp(aProperty, XRE_EXECUTABLE_FILE) && gArgv[0]) {
     nsCOMPtr<nsIFile> lf;
     rv = XRE_GetBinaryPath(gArgv[0], getter_AddRefs(lf));
     if (NS_SUCCEEDED(rv))
       file = lf;
   }
   else if (!strcmp(aProperty, NS_APP_PROFILE_DIR_STARTUP) && mProfileDir) {
     return mProfileDir->Clone(aFile);
   }
   else if (!strcmp(aProperty, NS_APP_PROFILE_LOCAL_DIR_STARTUP)) {
     if (mProfileLocalDir)
       return mProfileLocalDir->Clone(aFile);
     if (mProfileDir)
       return mProfileDir->Clone(aFile);
     if (mAppProvider)
       return mAppProvider->GetFile(NS_APP_PROFILE_DIR_STARTUP, aPersistent,
                                    aFile);
   }
 #if defined(XP_UNIX) || defined(XP_MACOSX)
   else if (!strcmp(aProperty, XRE_SYS_LOCAL_EXTENSION_PARENT_DIR)) {
 #ifdef ENABLE_SYSTEM_EXTENSION_DIRS
     return GetSystemExtensionsDirectory(aFile);
 #else
     return NS_ERROR_FAILURE;
 #endif
   }
 #endif
 #if defined(XP_UNIX) && !defined(XP_MACOSX)
   else if (!strcmp(aProperty, XRE_SYS_SHARE_EXTENSION_PARENT_DIR)) {
 #ifdef ENABLE_SYSTEM_EXTENSION_DIRS
 #if defined(__OpenBSD__) || defined(__FreeBSD__)
     static const char *const sysLExtDir = "/usr/local/share/mozilla/extensions";
 #else
     static const char *const sysLExtDir = "/usr/share/mozilla/extensions";
 #endif
     return NS_NewNativeLocalFile(nsDependentCString(sysLExtDir),
                                  false, aFile);
 #else
     return NS_ERROR_FAILURE;
 #endif
   }
 #endif
   else if (!strcmp(aProperty, XRE_USER_SYS_EXTENSION_DIR)) {
 #ifdef ENABLE_SYSTEM_EXTENSION_DIRS
     return GetSysUserExtensionsDirectory(aFile);
 #else
     return NS_ERROR_FAILURE;
 #endif
   }
   else if (!strcmp(aProperty, XRE_APP_DISTRIBUTION_DIR)) {
     bool persistent = false;
     rv = GetFile(XRE_EXECUTABLE_FILE, &persistent, getter_AddRefs(file));
     if (NS_SUCCEEDED(rv))
       rv = file->SetNativeLeafName(NS_LITERAL_CSTRING("distribution"));
   }
   else if (NS_SUCCEEDED(GetProfileStartupDir(getter_AddRefs(file)))) {
     // We need to allow component, xpt, and chrome registration to
     // occur prior to the profile-after-change notification.
     if (!strcmp(aProperty, NS_APP_USER_CHROME_DIR)) {
       rv = file->AppendNative(NS_LITERAL_CSTRING("chrome"));
     }
   }
   if (NS_SUCCEEDED(rv) && file) {
     NS_ADDREF(*aFile = file);
     return NS_OK;
   }
   bool ensureFilePermissions = false;
   if (NS_SUCCEEDED(GetProfileDir(getter_AddRefs(file)))) {
     if (!strcmp(aProperty, NS_APP_PREFS_50_DIR)) {
       rv = NS_OK;
     }
     else if (!strcmp(aProperty, NS_APP_PREFS_50_FILE)) {
       rv = file->AppendNative(NS_LITERAL_CSTRING("prefs.js"));
     }
     else if (!strcmp(aProperty, NS_METRO_APP_PREFS_50_FILE)) {
       rv = file->AppendNative(NS_LITERAL_CSTRING("metro-prefs.js"));
     }
     else if (!strcmp(aProperty, NS_LOCALSTORE_UNSAFE_FILE)) {
       rv = file->AppendNative(NS_LITERAL_CSTRING("localstore.rdf"));
     }
     else if (!strcmp(aProperty, NS_APP_LOCALSTORE_50_FILE)) {
       if (gSafeMode) {
         rv = file->AppendNative(NS_LITERAL_CSTRING("localstore-safe.rdf"));
         file->Remove(false);
       }
       else {
         rv = file->AppendNative(NS_LITERAL_CSTRING("localstore.rdf"));
         EnsureProfileFileExists(file);
         ensureFilePermissions = true;
       }
     }
     else if (!strcmp(aProperty, NS_APP_USER_MIMETYPES_50_FILE)) {
       rv = file->AppendNative(NS_LITERAL_CSTRING("mimeTypes.rdf"));
       EnsureProfileFileExists(file);
       ensureFilePermissions = true;
     }
     else if (!strcmp(aProperty, NS_APP_DOWNLOADS_50_FILE)) {
       rv = file->AppendNative(NS_LITERAL_CSTRING("downloads.rdf"));
     }
     else if (!strcmp(aProperty, NS_APP_PREFS_OVERRIDE_DIR)) {
       rv = mProfileDir->Clone(getter_AddRefs(file));
       nsresult tmp = file->AppendNative(NS_LITERAL_CSTRING(PREF_OVERRIDE_DIRNAME));
       if (NS_FAILED(tmp)) {
         rv = tmp;
       }
       tmp = EnsureDirectoryExists(file);
       if (NS_FAILED(tmp)) {
         rv = tmp;
       }
     }
   }
   if (NS_FAILED(rv) || !file)
     return NS_ERROR_FAILURE;
   if (ensureFilePermissions) {
     bool fileToEnsureExists;
     bool isWritable;
     if (NS_SUCCEEDED(file->Exists(&fileToEnsureExists)) && fileToEnsureExists
         && NS_SUCCEEDED(file->IsWritable(&isWritable)) && !isWritable) {
       uint32_t permissions;
       if (NS_SUCCEEDED(file->GetPermissions(&permissions))) {
         rv = file->SetPermissions(permissions | 0600);
         NS_ASSERTION(NS_SUCCEEDED(rv), "failed to ensure file permissions");
       }
     }
   }
   NS_ADDREF(*aFile = file);
   return NS_OK;
 }
 static void
 LoadDirIntoArray(nsIFile* dir,
                  const char *const *aAppendList,
                  nsCOMArray<nsIFile>& aDirectories)
 {
   if (!dir)
     return;
   nsCOMPtr<nsIFile> subdir;
   dir->Clone(getter_AddRefs(subdir));
   if (!subdir)
     return;
   for (const char *const *a = aAppendList; *a; ++a) {
     subdir->AppendNative(nsDependentCString(*a));
   }
   bool exists;
   if (NS_SUCCEEDED(subdir->Exists(&exists)) && exists) {
     aDirectories.AppendObject(subdir);
   }
 }
 static void
 LoadDirsIntoArray(nsCOMArray<nsIFile>& aSourceDirs,
                   const char *const* aAppendList,
                   nsCOMArray<nsIFile>& aDirectories)
 {
   nsCOMPtr<nsIFile> appended;
   bool exists;
   for (int32_t i = 0; i < aSourceDirs.Count(); ++i) {
     aSourceDirs[i]->Clone(getter_AddRefs(appended));
     if (!appended)
       continue;
     nsAutoCString leaf;
     appended->GetNativeLeafName(leaf);
     if (!Substring(leaf, leaf.Length() - 4).Equals(NS_LITERAL_CSTRING(".xpi"))) {
       LoadDirIntoArray(appended,
                        aAppendList,
                        aDirectories);
     }
     else if (NS_SUCCEEDED(appended->Exists(&exists)) && exists)
       aDirectories.AppendObject(appended);
   }
 }
 NS_IMETHODIMP
 nsXREDirProvider::GetFiles(const char* aProperty, nsISimpleEnumerator** aResult)
 {
   nsresult rv;
   nsCOMPtr<nsISimpleEnumerator> appEnum;
   nsCOMPtr<nsIDirectoryServiceProvider2>
     appP2(do_QueryInterface(mAppProvider));
   if (appP2) {
     rv = appP2->GetFiles(aProperty, getter_AddRefs(appEnum));
     if (NS_FAILED(rv)) {
       appEnum = nullptr;
     }
     else if (rv != NS_SUCCESS_AGGREGATE_RESULT) {
       NS_ADDREF(*aResult = appEnum);
       return NS_OK;
     }
   }
   nsCOMPtr<nsISimpleEnumerator> xreEnum;
   rv = GetFilesInternal(aProperty, getter_AddRefs(xreEnum));
   if (NS_FAILED(rv)) {
     if (appEnum) {
       NS_ADDREF(*aResult = appEnum);
       return NS_SUCCESS_AGGREGATE_RESULT;
     }
     return rv;
   }
   rv = NS_NewUnionEnumerator(aResult, appEnum, xreEnum);
   if (NS_FAILED(rv))
     return rv;
   return NS_SUCCESS_AGGREGATE_RESULT;
 }
 static void
 LoadExtensionDirectories(nsINIParser &parser,
                          const char *aSection,
                          nsCOMArray<nsIFile> &aDirectories,
                          NSLocationType aType)
 {
   nsresult rv;
   int32_t i = 0;
   do {
     nsAutoCString buf("Extension");
     buf.AppendInt(i++);
     nsAutoCString path;
     rv = parser.GetString(aSection, buf.get(), path);
     if (NS_FAILED(rv))
       return;
     nsCOMPtr<nsIFile> dir = do_CreateInstance("@mozilla.org/file/local;1", &rv);
     if (NS_FAILED(rv))
       continue;
     rv = dir->SetPersistentDescriptor(path);
     if (NS_FAILED(rv))
       continue;
     aDirectories.AppendObject(dir);
     if (Substring(path, path.Length() - 4).Equals(NS_LITERAL_CSTRING(".xpi"))) {
       XRE_AddJarManifestLocation(aType, dir);
     }
     else {
       nsCOMPtr<nsIFile> manifest =
         CloneAndAppend(dir, "chrome.manifest");
       XRE_AddManifestLocation(aType, manifest);
     }
   }
   while (true);
 }
 void
 nsXREDirProvider::LoadExtensionBundleDirectories()
 {
   if (!mozilla::Preferences::GetBool("extensions.defaultProviders.enabled", true))
     return;
   if (mProfileDir && !gSafeMode) {
     nsCOMPtr<nsIFile> extensionsINI;
     mProfileDir->Clone(getter_AddRefs(extensionsINI));
     if (!extensionsINI)
       return;
     extensionsINI->AppendNative(NS_LITERAL_CSTRING("extensions.ini"));
     nsCOMPtr<nsIFile> extensionsINILF =
       do_QueryInterface(extensionsINI);
     if (!extensionsINILF)
       return;
     nsINIParser parser;
     nsresult rv = parser.Init(extensionsINILF);
     if (NS_FAILED(rv))
       return;
     LoadExtensionDirectories(parser, "ExtensionDirs", mExtensionDirectories,
                              NS_COMPONENT_LOCATION);
     LoadExtensionDirectories(parser, "ThemeDirs", mThemeDirectories,
                              NS_SKIN_LOCATION);
   }
 }
 void
 nsXREDirProvider::LoadAppBundleDirs()
 {
   nsCOMPtr<nsIFile> dir;
   bool persistent = false;
   nsresult rv = GetFile(XRE_EXECUTABLE_FILE, &persistent, getter_AddRefs(dir));
   if (NS_FAILED(rv))
     return;
   dir->SetNativeLeafName(NS_LITERAL_CSTRING("distribution"));
   dir->AppendNative(NS_LITERAL_CSTRING("bundles"));
   nsCOMPtr<nsISimpleEnumerator> e;
   rv = dir->GetDirectoryEntries(getter_AddRefs(e));
   if (NS_FAILED(rv))
     return;
   nsCOMPtr<nsIDirectoryEnumerator> files = do_QueryInterface(e);
   if (!files)
     return;
   nsCOMPtr<nsIFile> subdir;
   while (NS_SUCCEEDED(files->GetNextFile(getter_AddRefs(subdir))) && subdir) {
     mAppBundleDirectories.AppendObject(subdir);
     nsCOMPtr<nsIFile> manifest =
       CloneAndAppend(subdir, "chrome.manifest");
     XRE_AddManifestLocation(NS_COMPONENT_LOCATION, manifest);
   }
 }
 static const char *const kAppendPrefDir[] = { "defaults", "preferences", nullptr };
 #ifdef DEBUG_bsmedberg
 static void
 DumpFileArray(const char *key,
               nsCOMArray<nsIFile> dirs)
 {
   fprintf(stderr, "nsXREDirProvider::GetFilesInternal(%s)\n", key);
   nsAutoCString path;
   for (int32_t i = 0; i < dirs.Count(); ++i) {
     dirs[i]->GetNativePath(path);
     fprintf(stderr, "  %s\n", path.get());
   }
 }
 #endif // DEBUG_bsmedberg
 nsresult
 nsXREDirProvider::GetFilesInternal(const char* aProperty,
                                    nsISimpleEnumerator** aResult)
 {
   nsresult rv = NS_OK;
   *aResult = nullptr;
   if (!strcmp(aProperty, XRE_EXTENSIONS_DIR_LIST)) {
     nsCOMArray<nsIFile> directories;
     static const char *const kAppendNothing[] = { nullptr };
     LoadDirsIntoArray(mAppBundleDirectories,
                       kAppendNothing, directories);
     LoadDirsIntoArray(mExtensionDirectories,
                       kAppendNothing, directories);
     rv = NS_NewArrayEnumerator(aResult, directories);
   }
   else if (!strcmp(aProperty, NS_APP_PREFS_DEFAULTS_DIR_LIST)) {
     nsCOMArray<nsIFile> directories;
     LoadDirIntoArray(mXULAppDir, kAppendPrefDir, directories);
     LoadDirsIntoArray(mAppBundleDirectories,
                       kAppendPrefDir, directories);
     rv = NS_NewArrayEnumerator(aResult, directories);
   }
   else if (!strcmp(aProperty, NS_EXT_PREFS_DEFAULTS_DIR_LIST)) {
     nsCOMArray<nsIFile> directories;
     LoadDirsIntoArray(mExtensionDirectories,
                       kAppendPrefDir, directories);
     if (mProfileDir) {
       nsCOMPtr<nsIFile> overrideFile;
       mProfileDir->Clone(getter_AddRefs(overrideFile));
       overrideFile->AppendNative(NS_LITERAL_CSTRING(PREF_OVERRIDE_DIRNAME));
       bool exists;
       if (NS_SUCCEEDED(overrideFile->Exists(&exists)) && exists)
         directories.AppendObject(overrideFile);
     }
     rv = NS_NewArrayEnumerator(aResult, directories);
   }
   else if (!strcmp(aProperty, NS_APP_CHROME_DIR_LIST)) {
     // NS_APP_CHROME_DIR_LIST is only used to get default (native) icons
     // for OS window decoration.
     static const char *const kAppendChromeDir[] = { "chrome", nullptr };
     nsCOMArray<nsIFile> directories;
     LoadDirIntoArray(mXULAppDir,
                      kAppendChromeDir,
                      directories);
     LoadDirsIntoArray(mAppBundleDirectories,
                       kAppendChromeDir,
                       directories);
     LoadDirsIntoArray(mExtensionDirectories,
                       kAppendChromeDir,
                       directories);
     rv = NS_NewArrayEnumerator(aResult, directories);
   }
   else if (!strcmp(aProperty, NS_APP_PLUGINS_DIR_LIST)) {
     nsCOMArray<nsIFile> directories;
     if (mozilla::Preferences::GetBool("plugins.load_appdir_plugins", false)) {
       nsCOMPtr<nsIFile> appdir;
       rv = XRE_GetBinaryPath(gArgv[0], getter_AddRefs(appdir));
       if (NS_SUCCEEDED(rv)) {
         appdir->SetNativeLeafName(NS_LITERAL_CSTRING("plugins"));
         directories.AppendObject(appdir);
       }
     }
     static const char *const kAppendPlugins[] = { "plugins", nullptr };
     // The root dirserviceprovider does quite a bit for us: we're mainly
     // interested in xulapp and extension-provided plugins.
     LoadDirsIntoArray(mAppBundleDirectories,
                       kAppendPlugins,
                       directories);
     LoadDirsIntoArray(mExtensionDirectories,
                       kAppendPlugins,
                       directories);
     if (mProfileDir) {
       nsCOMArray<nsIFile> profileDir;
       profileDir.AppendObject(mProfileDir);
       LoadDirsIntoArray(profileDir,
                         kAppendPlugins,
                         directories);
     }
     rv = NS_NewArrayEnumerator(aResult, directories);
     NS_ENSURE_SUCCESS(rv, rv);
     rv = NS_SUCCESS_AGGREGATE_RESULT;
   }
   else
     rv = NS_ERROR_FAILURE;
   return rv;
 }
 NS_IMETHODIMP
 nsXREDirProvider::GetDirectory(nsIFile* *aResult)
 {
   NS_ENSURE_TRUE(mProfileDir, NS_ERROR_NOT_INITIALIZED);
   return mProfileDir->Clone(aResult);
 }
 NS_IMETHODIMP
 nsXREDirProvider::DoStartup()
 {
   if (!mProfileNotified) {
     nsCOMPtr<nsIObserverService> obsSvc =
       mozilla::services::GetObserverService();
     if (!obsSvc) return NS_ERROR_FAILURE;
     mProfileNotified = true;
     /*
        Setup prefs before profile-do-change to be able to use them to track
        crashes and because we want to begin crash tracking before other code run
        from this notification since they may cause crashes.
     */
     nsresult rv = mozilla::Preferences::ResetAndReadUserPrefs();
     if (NS_FAILED(rv)) NS_WARNING("Failed to setup pref service.");
     bool safeModeNecessary = false;
     nsCOMPtr<nsIAppStartup> appStartup (do_GetService(NS_APPSTARTUP_CONTRACTID));
     if (appStartup) {
       rv = appStartup->TrackStartupCrashBegin(&safeModeNecessary);
       if (NS_FAILED(rv) && rv != NS_ERROR_NOT_AVAILABLE)
         NS_WARNING("Error while beginning startup crash tracking");
       if (!gSafeMode && safeModeNecessary) {
         appStartup->RestartInSafeMode(nsIAppStartup::eForceQuit);
         return NS_OK;
       }
     }
     static const char16_t kStartup[] = {'s','t','a','r','t','u','p','\0'};
     obsSvc->NotifyObservers(nullptr, "profile-do-change", kStartup);
     // Init the Extension Manager
     nsCOMPtr<nsIObserver> em = do_GetService("@mozilla.org/addons/integration;1");
     if (em) {
       em->Observe(nullptr, "addons-startup", nullptr);
     } else {
       NS_WARNING("Failed to create Addons Manager.");
     }
     LoadExtensionBundleDirectories();
     obsSvc->NotifyObservers(nullptr, "load-extension-defaults", nullptr);
     obsSvc->NotifyObservers(nullptr, "profile-after-change", kStartup);
     // Any component that has registered for the profile-after-change category
     // should also be created at this time.
     (void)NS_CreateServicesFromCategory("profile-after-change", nullptr,
                                         "profile-after-change");
     if (gSafeMode && safeModeNecessary) {
       static const char16_t kCrashed[] = {'c','r','a','s','h','e','d','\0'};
       obsSvc->NotifyObservers(nullptr, "safemode-forced", kCrashed);
     }
     // 1 = Regular mode, 2 = Safe mode, 3 = Safe mode forced
     int mode = 1;
     if (gSafeMode) {
       if (safeModeNecessary)
         mode = 3;
       else
         mode = 2;
     }
     mozilla::Telemetry::Accumulate(mozilla::Telemetry::SAFE_MODE_USAGE, mode);
     obsSvc->NotifyObservers(nullptr, "profile-initial-state", nullptr);
   }
   return NS_OK;
 }
 void
 nsXREDirProvider::DoShutdown()
 {
   if (mProfileNotified) {
     nsCOMPtr<nsIObserverService> obsSvc =
       mozilla::services::GetObserverService();
     NS_ASSERTION(obsSvc, "No observer service?");
     if (obsSvc) {
       static const char16_t kShutdownPersist[] =
         {'s','h','u','t','d','o','w','n','-','p','e','r','s','i','s','t','\0'};
       obsSvc->NotifyObservers(nullptr, "profile-change-net-teardown", kShutdownPersist);
       obsSvc->NotifyObservers(nullptr, "profile-change-teardown", kShutdownPersist);
       // Phase 2c: Now that things are torn down, force JS GC so that things which depend on
       // resources which are about to go away in "profile-before-change" are destroyed first.
       nsCOMPtr<nsIJSRuntimeService> rtsvc
         (do_GetService("@mozilla.org/js/xpc/RuntimeService;1"));
       if (rtsvc)
       {
         JSRuntime *rt = nullptr;
         rtsvc->GetRuntime(&rt);
         if (rt)
           ::JS_GC(rt);
       }
       // Phase 3: Notify observers of a profile change
       obsSvc->NotifyObservers(nullptr, "profile-before-change", kShutdownPersist);
       obsSvc->NotifyObservers(nullptr, "profile-before-change2", kShutdownPersist);
     }
     mProfileNotified = false;
   }
 }
 #ifdef XP_WIN
 static nsresult
 GetShellFolderPath(int folder, nsAString& _retval)
 {
   wchar_t* buf;
   uint32_t bufLength = _retval.GetMutableData(&buf, MAXPATHLEN + 3);
   NS_ENSURE_TRUE(bufLength >= (MAXPATHLEN + 3), NS_ERROR_OUT_OF_MEMORY);
   nsresult rv = NS_OK;
   LPITEMIDLIST pItemIDList = nullptr;
   if (SUCCEEDED(SHGetSpecialFolderLocation(nullptr, folder, &pItemIDList)) &&
       SHGetPathFromIDListW(pItemIDList, buf)) {
     // We're going to use wcslen (wcsnlen not available in msvc7.1) so make
     // sure to null terminate.
     buf[bufLength - 1] = L'\0';
     _retval.SetLength(wcslen(buf));
   } else {
     _retval.SetLength(0);
     rv = NS_ERROR_NOT_AVAILABLE;
   }
   CoTaskMemFree(pItemIDList);
   return rv;
 }
 /**
  * Provides a fallback for getting the path to APPDATA or LOCALAPPDATA by
  * querying the registry when the call to SHGetSpecialFolderLocation or
  * SHGetPathFromIDListW is unable to provide these paths (Bug 513958).
  */
 static nsresult
 GetRegWindowsAppDataFolder(bool aLocal, nsAString& _retval)
 {
   HKEY key;
   NS_NAMED_LITERAL_STRING(keyName,
   "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders");
   DWORD res = ::RegOpenKeyExW(HKEY_CURRENT_USER, keyName.get(), 0, KEY_READ,
                               &key);
   if (res != ERROR_SUCCESS) {
     _retval.SetLength(0);
     return NS_ERROR_NOT_AVAILABLE;
   }
   DWORD type, size;
   res = RegQueryValueExW(key, (aLocal ? L"Local AppData" : L"AppData"),
                          nullptr, &type, nullptr, &size);
   // The call to RegQueryValueExW must succeed, the type must be REG_SZ, the
   // buffer size must not equal 0, and the buffer size be a multiple of 2.
   if (res != ERROR_SUCCESS || type != REG_SZ || size == 0 || size % 2 != 0) {
     ::RegCloseKey(key);
     _retval.SetLength(0);
     return NS_ERROR_NOT_AVAILABLE;
   }
   // |size| may or may not include room for the terminating null character
   DWORD resultLen = size / 2;
   _retval.SetLength(resultLen);
   nsAString::iterator begin;
   _retval.BeginWriting(begin);
   if (begin.size_forward() != resultLen) {
     ::RegCloseKey(key);
     _retval.SetLength(0);
     return NS_ERROR_NOT_AVAILABLE;
   }
   res = RegQueryValueExW(key, (aLocal ? L"Local AppData" : L"AppData"),
                          nullptr, nullptr, (LPBYTE) begin.get(), &size);
   ::RegCloseKey(key);
   if (res != ERROR_SUCCESS) {
     _retval.SetLength(0);
     return NS_ERROR_NOT_AVAILABLE;
   }
   if (!_retval.CharAt(resultLen - 1)) {
     // It was already null terminated.
     _retval.Truncate(resultLen - 1);
   }
   return NS_OK;
 }
 static bool
 GetCachedHash(HKEY rootKey, const nsAString &regPath, const nsAString &path,
               nsAString &cachedHash)
 {
   HKEY baseKey;
   if (RegOpenKeyExW(rootKey, reinterpret_cast<const wchar_t*>(regPath.BeginReading()), 0, KEY_READ, &baseKey) !=
       ERROR_SUCCESS) {
     return false;
   }
   wchar_t cachedHashRaw[512];
   DWORD bufferSize = sizeof(cachedHashRaw);
   LONG result = RegQueryValueExW(baseKey, reinterpret_cast<const wchar_t*>(path.BeginReading()), 0, nullptr,
                                  (LPBYTE)cachedHashRaw, &bufferSize);
   RegCloseKey(baseKey);
   if (result == ERROR_SUCCESS) {
     cachedHash.Assign(cachedHashRaw);
   }
   return ERROR_SUCCESS == result;
 }
 #endif
 nsresult
 nsXREDirProvider::GetUpdateRootDir(nsIFile* *aResult)
 {
   nsCOMPtr<nsIFile> updRoot;
 #if defined(MOZ_WIDGET_GONK)
   nsresult rv = NS_NewNativeLocalFile(nsDependentCString("/data/local"),
                                       true,
                                       getter_AddRefs(updRoot));
   NS_ENSURE_SUCCESS(rv, rv);
 #else
   nsCOMPtr<nsIFile> appFile;
   bool per = false;
   nsresult rv = GetFile(XRE_EXECUTABLE_FILE, &per, getter_AddRefs(appFile));
   NS_ENSURE_SUCCESS(rv, rv);
   rv = appFile->GetParent(getter_AddRefs(updRoot));
   NS_ENSURE_SUCCESS(rv, rv);
 #ifdef XP_WIN
   nsAutoString pathHash;
   bool pathHashResult = false;
   bool hasVendor = gAppData->vendor && strlen(gAppData->vendor) != 0;
   nsAutoString appDirPath;
   if (SUCCEEDED(updRoot->GetPath(appDirPath))) {
     // Figure out where we should check for a cached hash value. If the
     // application doesn't have the nsXREAppData vendor value defined check
     // under SOFTWARE\Mozilla.
     wchar_t regPath[1024] = { L'\0' };
     swprintf_s(regPath, mozilla::ArrayLength(regPath), L"SOFTWARE\\%S\\%S\\TaskBarIDs",
                (hasVendor ? gAppData->vendor : "Mozilla"), MOZ_APP_BASENAME);
     // If we pre-computed the hash, grab it from the registry.
     pathHashResult = GetCachedHash(HKEY_LOCAL_MACHINE,
                                    nsDependentString(regPath), appDirPath,
                                    pathHash);
     if (!pathHashResult) {
       pathHashResult = GetCachedHash(HKEY_CURRENT_USER,
                                      nsDependentString(regPath), appDirPath,
                                      pathHash);
     }
   }
   // Get the local app data directory and if a vendor name exists append it.
   // If only a product name exists, append it.  If neither exist fallback to
   // old handling.  We don't use the product name on purpose because we want a
   // shared update directory for different apps run from the same path (like
   // Metro & Desktop).
   nsCOMPtr<nsIFile> localDir;
   if (pathHashResult && (hasVendor || gAppData->name) &&
       NS_SUCCEEDED(GetUserDataDirectoryHome(getter_AddRefs(localDir), true)) &&
       NS_SUCCEEDED(localDir->AppendNative(nsDependentCString(hasVendor ?
                                           gAppData->vendor : gAppData->name))) &&
       NS_SUCCEEDED(localDir->Append(NS_LITERAL_STRING("updates"))) &&
       NS_SUCCEEDED(localDir->Append(pathHash))) {
     NS_ADDREF(*aResult = localDir);
     return NS_OK;
   }
   nsAutoString appPath;
   rv = updRoot->GetPath(appPath);
   NS_ENSURE_SUCCESS(rv, rv);
   // AppDir may be a short path. Convert to long path to make sure
   // the consistency of the update folder location
   nsString longPath;
   wchar_t* buf;
   uint32_t bufLength = longPath.GetMutableData(&buf, MAXPATHLEN);
   NS_ENSURE_TRUE(bufLength >= MAXPATHLEN, NS_ERROR_OUT_OF_MEMORY);
   DWORD len = GetLongPathNameW(appPath.get(), buf, bufLength);
   // Failing GetLongPathName() is not fatal.
   if (len <= 0 || len >= bufLength)
     longPath.Assign(appPath);
   else
     longPath.SetLength(len);
   // Use <UserLocalDataDir>\updates\<relative path to app dir from
   // Program Files> if app dir is under Program Files to avoid the
   // folder virtualization mess on Windows Vista
   nsAutoString programFiles;
   rv = GetShellFolderPath(CSIDL_PROGRAM_FILES, programFiles);
   NS_ENSURE_SUCCESS(rv, rv);
   programFiles.AppendLiteral("\\");
   uint32_t programFilesLen = programFiles.Length();
   nsAutoString programName;
   if (_wcsnicmp(programFiles.get(), longPath.get(), programFilesLen) == 0) {
     programName = Substring(longPath, programFilesLen);
   } else {
     // We need the update root directory to live outside of the installation
     // directory, because otherwise the updater writing the log file can cause
     // the directory to be locked, which prevents it from being replaced after
     // background updates.
     programName.AssignASCII(MOZ_APP_NAME);
   }
   rv = GetUserLocalDataDirectory(getter_AddRefs(updRoot));
   NS_ENSURE_SUCCESS(rv, rv);
   rv = updRoot->AppendRelativePath(programName);
   NS_ENSURE_SUCCESS(rv, rv);
 #endif
 #endif
   NS_ADDREF(*aResult = updRoot);
   return NS_OK;
 }
 nsresult
 nsXREDirProvider::GetProfileStartupDir(nsIFile* *aResult)
 {
   if (mProfileDir)
     return mProfileDir->Clone(aResult);
   if (mAppProvider) {
     nsCOMPtr<nsIFile> needsclone;
     bool dummy;
     nsresult rv = mAppProvider->GetFile(NS_APP_PROFILE_DIR_STARTUP,
                                         &dummy,
                                         getter_AddRefs(needsclone));
     if (NS_SUCCEEDED(rv))
       return needsclone->Clone(aResult);
   }
   return NS_ERROR_FAILURE;
 }
 nsresult
 nsXREDirProvider::GetProfileDir(nsIFile* *aResult)
 {
   if (mProfileDir) {
     if (!mProfileNotified)
       return NS_ERROR_FAILURE;
     return mProfileDir->Clone(aResult);
   }
   if (mAppProvider) {
     nsCOMPtr<nsIFile> needsclone;
     bool dummy;
     nsresult rv = mAppProvider->GetFile(NS_APP_USER_PROFILE_50_DIR,
                                         &dummy,
                                         getter_AddRefs(needsclone));
     if (NS_SUCCEEDED(rv))
       return needsclone->Clone(aResult);
   }
   return NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR, aResult);
 }
 nsresult
 nsXREDirProvider::GetUserDataDirectoryHome(nsIFile** aFile, bool aLocal)
 {
   // Copied from nsAppFileLocationProvider (more or less)
   NS_ENSURE_ARG_POINTER(aFile);
   nsCOMPtr<nsIFile> localDir;
   nsresult rv = GetAppDir()->Clone(getter_AddRefs(localDir));
   NS_ENSURE_SUCCESS(rv, rv);
   int levelsToRemove = 1; // In FF21+, appDir points to browser subdirectory.
 #if defined(XP_MACOSX)
   levelsToRemove += 2;
 #endif
   while (localDir && (levelsToRemove > 0)) {
     // When crawling up the hierarchy, components named "." do not count.
     nsAutoCString removedName;
     rv = localDir->GetNativeLeafName(removedName);
     NS_ENSURE_SUCCESS(rv, rv);
     bool didRemove = !removedName.Equals(".");
     // Remove a directory component.
     nsCOMPtr<nsIFile> parentDir;
     rv = localDir->GetParent(getter_AddRefs(parentDir));
     NS_ENSURE_SUCCESS(rv, rv);
     localDir = parentDir;
     if (didRemove)
       --levelsToRemove;
   }
   if (!localDir)
     return NS_ERROR_FAILURE;
   rv = localDir->AppendRelativeNativePath(NS_LITERAL_CSTRING("TorBrowser"
                                      XPCOM_FILE_PATH_SEPARATOR "Data"
                                      XPCOM_FILE_PATH_SEPARATOR "Browser"));
   NS_ENSURE_SUCCESS(rv, rv);
   if (aLocal) {
     rv = localDir->AppendNative(NS_LITERAL_CSTRING("Caches"));
     NS_ENSURE_SUCCESS(rv, rv);
   }
   NS_IF_ADDREF(*aFile = localDir);
   return rv;
 }
 nsresult
 nsXREDirProvider::GetSysUserExtensionsDirectory(nsIFile** aFile)
 {
   nsCOMPtr<nsIFile> localDir;
   nsresult rv = GetUserDataDirectoryHome(getter_AddRefs(localDir), false);
   NS_ENSURE_SUCCESS(rv, rv);
   rv = AppendSysUserExtensionPath(localDir);
   NS_ENSURE_SUCCESS(rv, rv);
   rv = EnsureDirectoryExists(localDir);
   NS_ENSURE_SUCCESS(rv, rv);
   NS_ADDREF(*aFile = localDir);
   return NS_OK;
 }
 #if defined(XP_UNIX) || defined(XP_MACOSX)
 nsresult
 nsXREDirProvider::GetSystemExtensionsDirectory(nsIFile** aFile)
 {
   nsresult rv;
   nsCOMPtr<nsIFile> localDir;
 #if defined(XP_MACOSX)
   FSRef fsRef;
   OSErr err = ::FSFindFolder(kOnSystemDisk, kApplicationSupportFolderType, kCreateFolder, &fsRef);
   NS_ENSURE_FALSE(err, NS_ERROR_FAILURE);
   rv = NS_NewNativeLocalFile(EmptyCString(), true, getter_AddRefs(localDir));
   NS_ENSURE_SUCCESS(rv, rv);
   nsCOMPtr<nsILocalFileMac> dirFileMac = do_QueryInterface(localDir);
   NS_ENSURE_TRUE(dirFileMac, NS_ERROR_UNEXPECTED);
   rv = dirFileMac->InitWithFSRef(&fsRef);
   NS_ENSURE_SUCCESS(rv, rv);
   localDir = do_QueryInterface(dirFileMac, &rv);
   static const char* const sXR = "Mozilla";
   rv = localDir->AppendNative(nsDependentCString(sXR));
   NS_ENSURE_SUCCESS(rv, rv);
   static const char* const sExtensions = "Extensions";
   rv = localDir->AppendNative(nsDependentCString(sExtensions));
   NS_ENSURE_SUCCESS(rv, rv);
 #elif defined(XP_UNIX)
   static const char *const sysSExtDir =
 #ifdef HAVE_USR_LIB64_DIR
     "/usr/lib64/mozilla/extensions";
 #elif defined(__OpenBSD__) || defined(__FreeBSD__)
     "/usr/local/lib/mozilla/extensions";
 #else
     "/usr/lib/mozilla/extensions";
 #endif
   rv = NS_NewNativeLocalFile(nsDependentCString(sysSExtDir), false,
                              getter_AddRefs(localDir));
   NS_ENSURE_SUCCESS(rv, rv);
 #endif
   NS_ADDREF(*aFile = localDir);
   return NS_OK;
 }
 #endif
 nsresult
 nsXREDirProvider::GetUserDataDirectory(nsIFile** aFile, bool aLocal,
                                        const nsACString* aProfileName,
                                        const nsACString* aAppName,
                                        const nsACString* aVendorName)
 {
   nsCOMPtr<nsIFile> localDir;
   nsresult rv = GetUserDataDirectoryHome(getter_AddRefs(localDir), aLocal);
   NS_ENSURE_SUCCESS(rv, rv);
   rv = AppendProfilePath(localDir, aProfileName, aAppName, aVendorName, aLocal);
   NS_ENSURE_SUCCESS(rv, rv);
 #ifdef DEBUG_jungshik
   nsAutoCString cwd;
   localDir->GetNativePath(cwd);
   printf("nsXREDirProvider::GetUserDataDirectory: %s\n", cwd.get());
 #endif
   rv = EnsureDirectoryExists(localDir);
   NS_ENSURE_SUCCESS(rv, rv);
   NS_ADDREF(*aFile = localDir);
   return NS_OK;
 }
 nsresult
 nsXREDirProvider::EnsureDirectoryExists(nsIFile* aDirectory)
 {
   bool exists;
   nsresult rv = aDirectory->Exists(&exists);
   NS_ENSURE_SUCCESS(rv, rv);
 #ifdef DEBUG_jungshik
   if (!exists) {
     nsAutoCString cwd;
     aDirectory->GetNativePath(cwd);
     printf("nsXREDirProvider::EnsureDirectoryExists: %s does not\n", cwd.get());
   }
 #endif
   if (!exists)
     rv = aDirectory->Create(nsIFile::DIRECTORY_TYPE, 0700);
 #ifdef DEBUG_jungshik
   if (NS_FAILED(rv))
     NS_WARNING("nsXREDirProvider::EnsureDirectoryExists: create failed");
 #endif
   return rv;
 }
 void
 nsXREDirProvider::EnsureProfileFileExists(nsIFile *aFile)
 {
   nsresult rv;
   bool exists;
   rv = aFile->Exists(&exists);
   if (NS_FAILED(rv) || exists) return;
   nsAutoCString leafName;
   rv = aFile->GetNativeLeafName(leafName);
   if (NS_FAILED(rv)) return;
   nsCOMPtr<nsIFile> defaultsFile;
   rv = GetProfileDefaultsDir(getter_AddRefs(defaultsFile));
   if (NS_FAILED(rv)) return;
   rv = defaultsFile->AppendNative(leafName);
   if (NS_FAILED(rv)) return;
   defaultsFile->CopyToNative(mProfileDir, EmptyCString());
 }
 nsresult
 nsXREDirProvider::GetProfileDefaultsDir(nsIFile* *aResult)
 {
   NS_ASSERTION(mGREDir, "nsXREDirProvider not initialized.");
   NS_PRECONDITION(aResult, "Null out-param");
   nsresult rv;
   nsCOMPtr<nsIFile> defaultsDir;
   rv = GetAppDir()->Clone(getter_AddRefs(defaultsDir));
   NS_ENSURE_SUCCESS(rv, rv);
   rv = defaultsDir->AppendNative(NS_LITERAL_CSTRING("defaults"));
   NS_ENSURE_SUCCESS(rv, rv);
   rv = defaultsDir->AppendNative(NS_LITERAL_CSTRING("profile"));
   NS_ENSURE_SUCCESS(rv, rv);
   NS_ADDREF(*aResult = defaultsDir);
   return NS_OK;
 }
 nsresult
 nsXREDirProvider::AppendSysUserExtensionPath(nsIFile* aFile)
 {
   NS_ASSERTION(aFile, "Null pointer!");
   nsresult rv;
 #if defined (XP_MACOSX) || defined(XP_WIN)
   static const char* const sXR = "Mozilla";
   rv = aFile->AppendNative(nsDependentCString(sXR));
   NS_ENSURE_SUCCESS(rv, rv);
   static const char* const sExtensions = "Extensions";
   rv = aFile->AppendNative(nsDependentCString(sExtensions));
   NS_ENSURE_SUCCESS(rv, rv);
 #elif defined(XP_UNIX)
   static const char* const sXR = ".mozilla";
   rv = aFile->AppendNative(nsDependentCString(sXR));
   NS_ENSURE_SUCCESS(rv, rv);
   static const char* const sExtensions = "extensions";
   rv = aFile->AppendNative(nsDependentCString(sExtensions));
   NS_ENSURE_SUCCESS(rv, rv);
 #else
 #error "Don't know how to get XRE user extension path on your platform"
 #endif
   return NS_OK;
 }
 nsresult
 nsXREDirProvider::AppendProfilePath(nsIFile* aFile,
                                     const nsACString* aProfileName,
                                     const nsACString* aAppName,
                                     const nsACString* aVendorName,
                                     bool aLocal)
 {
   NS_ASSERTION(aFile, "Null pointer!");
   if (!gAppData) {
     return NS_ERROR_FAILURE;
   }
   nsAutoCString profile;
   if (aProfileName && !aProfileName->IsEmpty()) {
     profile = *aProfileName;
   } else if (gAppData->profile) {
     profile = gAppData->profile;
   }
   nsresult rv = NS_ERROR_FAILURE;
 #if defined (XP_MACOSX)
   if (!profile.IsEmpty()) {
     rv = AppendProfileString(aFile, profile.get());
     NS_ENSURE_SUCCESS(rv, rv);
   }
 #elif defined(XP_WIN)
   if (!profile.IsEmpty()) {
     rv = AppendProfileString(aFile, profile.get());
     NS_ENSURE_SUCCESS(rv, rv);
   }
 #elif defined(ANDROID)
   // The directory used for storing profiles
   // The parent of this directory is set in GetUserDataDirectoryHome
   // XXX: handle gAppData->profile properly
   // XXXsmaug ...and the rest of the profile creation!
   MOZ_ASSERT(!aAppName,
              "Profile creation for external applications is not implemented!");
   rv = aFile->AppendNative(nsDependentCString("mozilla"));
   NS_ENSURE_SUCCESS(rv, rv);
 #elif defined(XP_UNIX)
   if (!profile.IsEmpty()) {
     // Skip any leading path characters
     const char* profileStart = profile.get();
     while (*profileStart == '/' || *profileStart == '\\')
       profileStart++;
     // On the off chance that someone wanted their folder to be hidden don't
     // let it become ".."
     if (*profileStart == '.')
       profileStart++;
     // Make it hidden (by starting with ".").
     nsAutoCString folder(".");
     folder.Append(profileStart);
     ToLowerCase(folder);
     rv = AppendProfileString(aFile, folder.BeginReading());
     NS_ENSURE_SUCCESS(rv, rv);
   }
 #else
 #error "Don't know how to get profile path on your platform"
 #endif
   return NS_OK;
 }
 nsresult
 nsXREDirProvider::AppendProfileString(nsIFile* aFile, const char* aPath)
 {
   NS_ASSERTION(aFile, "Null file!");
   NS_ASSERTION(aPath, "Null path!");
   nsAutoCString pathDup(aPath);
   char* path = pathDup.BeginWriting();
   nsresult rv;
   char* subdir;
   while ((subdir = NS_strtok("/\\", &path))) {
     rv = aFile->AppendNative(nsDependentCString(subdir));
     NS_ENSURE_SUCCESS(rv, rv);
   }
   return NS_OK;
 }

The Tor Browser / annotate

toolkit/xre/nsXREDirProvider.cpp@129ffea94266 (annotated)

toolkit/xre/nsXREDirProvider.cpp