browser/components/dirprovider/DirectoryProvider.cpp

   1 /* ***** BEGIN LICENSE BLOCK *****
   2  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   3  *
   4  * The contents of this file are subject to the Mozilla Public License Version
   5  * 1.1 (the "License"); you may not use this file except in compliance with
   6  * the License. You may obtain a copy of the License at
   7  * http://www.mozilla.org/MPL/
   8  *
   9  * Software distributed under the License is distributed on an "AS IS" basis,
  10  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  11  * for the specific language governing rights and limitations under the
  12  * License.
  13  *
  14  * The Original Code is the Mozilla Firefox browser.
  15  *
  16  * The Initial Developer of the Original Code is
  17  * Benjamin Smedberg <benjamin@smedbergs.us>
  18  *
  19  * Portions created by the Initial Developer are Copyright (C) 2005
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *
  24  * Alternatively, the contents of this file may be used under the terms of
  25  * either the GNU General Public License Version 2 or later (the "GPL"), or
  26  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  27  * in which case the provisions of the GPL or the LGPL are applicable instead
  28  * of those above. If you wish to allow use of your version of this file only
  29  * under the terms of either the GPL or the LGPL, and not to allow others to
  30  * use your version of this file under the terms of the MPL, indicate your
  31  * decision by deleting the provisions above and replace them with the notice
  32  * and other provisions required by the GPL or the LGPL. If you do not delete
  33  * the provisions above, a recipient may use your version of this file under
  34  * the terms of any one of the MPL, the GPL or the LGPL.
  35  *
  36  * ***** END LICENSE BLOCK ***** */
  37
  38 #include "nsIDirectoryService.h"
  39 #include "DirectoryProvider.h"
  40
  41 #include "nsIFile.h"
  42 #include "nsISimpleEnumerator.h"
  43 #include "nsIPrefService.h"
  44 #include "nsIPrefBranch.h"
  45
  46 #include "nsArrayEnumerator.h"
  47 #include "nsEnumeratorUtils.h"
  48 #include "nsBrowserDirectoryServiceDefs.h"
  49 #include "nsAppDirectoryServiceDefs.h"
  50 #include "nsDirectoryServiceDefs.h"
  51 #include "nsCategoryManagerUtils.h"
  52 #include "nsComponentManagerUtils.h"
  53 #include "nsCOMArray.h"
  54 #include "nsDirectoryServiceUtils.h"
  55 #include "mozilla/ModuleUtils.h"
  56 #include "nsServiceManagerUtils.h"
  57 #include "nsStringAPI.h"
  58 #include "nsXULAppAPI.h"
  59
  60 namespace mozilla {
  61 namespace browser {
  62
  63 NS_IMPL_ISUPPORTS2(DirectoryProvider,
  64                    nsIDirectoryServiceProvider,
  65                    nsIDirectoryServiceProvider2)
  66
  67 NS_IMETHODIMP
  68 DirectoryProvider::GetFile(const char *aKey, bool *aPersist, nsIFile* *aResult)
  69 {
  70   nsresult rv;
  71
  72   *aResult = nsnull;
  73
  74   // NOTE: This function can be reentrant through the NS_GetSpecialDirectory
  75   // call, so be careful not to cause infinite recursion.
  76
  77   nsCOMPtr<nsIFile> file;
  78
  79   char const* leafName = nsnull;
  80
  81   if (!strcmp(aKey, NS_APP_BOOKMARKS_50_FILE)) {
  82     leafName = "bookmarks.html";
  83
  84     nsCOMPtr<nsIPrefBranch> prefs(do_GetService(NS_PREFSERVICE_CONTRACTID));
  85     if (prefs) {
  86       nsCString path;
  87       rv = prefs->GetCharPref("browser.bookmarks.file", getter_Copies(path));
  88       if (NS_SUCCEEDED(rv)) {
  89         NS_NewNativeLocalFile(path, true, (nsILocalFile**)(nsIFile**) getter_AddRefs(file));
  90       }
  91     }
  92   }
  93   else if (!strcmp(aKey, NS_APP_EXISTING_PREF_OVERRIDE)) {
  94     rv = NS_GetSpecialDirectory(NS_APP_DEFAULTS_50_DIR,
  95                                 getter_AddRefs(file));
  96     NS_ENSURE_SUCCESS(rv, rv);
  97
  98     file->AppendNative(NS_LITERAL_CSTRING("existing-profile-defaults.js"));
  99     file.swap(*aResult);
 100     return NS_OK;
 101   }
 102   else {
 103     return NS_ERROR_FAILURE;
 104   }
 105
 106   nsDependentCString leafstr(leafName);
 107
 108   nsCOMPtr<nsIFile> parentDir;
 109   if (file) {
 110     rv = file->GetParent(getter_AddRefs(parentDir));
 111     if (NS_FAILED(rv))
 112       return rv;
 113   }
 114   else {
 115     rv = NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR, getter_AddRefs(parentDir));
 116     if (NS_FAILED(rv))
 117       return rv;
 118
 119     rv = parentDir->Clone(getter_AddRefs(file));
 120     if (NS_FAILED(rv))
 121       return rv;
 122
 123     file->AppendNative(leafstr);
 124   }
 125
 126   *aPersist = true;
 127   NS_ADDREF(*aResult = file);
 128
 129   return NS_OK;
 130 }
 131
 132 static void
 133 AppendFileKey(const char *key, nsIProperties* aDirSvc,
 134               nsCOMArray<nsIFile> &array)
 135 {
 136   nsCOMPtr<nsIFile> file;
 137   nsresult rv = aDirSvc->Get(key, NS_GET_IID(nsIFile), getter_AddRefs(file));
 138   if (NS_FAILED(rv))
 139     return;
 140
 141   bool exists;
 142   rv = file->Exists(&exists);
 143   if (NS_FAILED(rv) || !exists)
 144     return;
 145
 146   array.AppendObject(file);
 147 }
 148
 149 // Appends the distribution-specific search engine directories to the
 150 // array.  The directory structure is as follows:
 151
 152 // appdir/
 153 // \- distribution/
 154 //    \- searchplugins/
 155 //       |- common/
 156 //       \- locale/
 157 //          |- <locale 1>/
 158 //          ...
 159 //          \- <locale N>/
 160
 161 // common engines are loaded for all locales.  If there is no locale
 162 // directory for the current locale, there is a pref:
 163 // "distribution.searchplugins.defaultLocale"
 164 // which specifies a default locale to use.
 165
 166 static void
 167 AppendDistroSearchDirs(nsIProperties* aDirSvc, nsCOMArray<nsIFile> &array)
 168 {
 169   nsCOMPtr<nsIFile> searchPlugins;
 170   nsresult rv = aDirSvc->Get(NS_XPCOM_CURRENT_PROCESS_DIR,
 171                              NS_GET_IID(nsIFile),
 172                              getter_AddRefs(searchPlugins));
 173   if (NS_FAILED(rv))
 174     return;
 175   searchPlugins->AppendNative(NS_LITERAL_CSTRING("distribution"));
 176   searchPlugins->AppendNative(NS_LITERAL_CSTRING("searchplugins"));
 177
 178   bool exists;
 179   rv = searchPlugins->Exists(&exists);
 180   if (NS_FAILED(rv) || !exists)
 181     return;
 182
 183   nsCOMPtr<nsIFile> commonPlugins;
 184   rv = searchPlugins->Clone(getter_AddRefs(commonPlugins));
 185   if (NS_SUCCEEDED(rv)) {
 186     commonPlugins->AppendNative(NS_LITERAL_CSTRING("common"));
 187     rv = commonPlugins->Exists(&exists);
 188     if (NS_SUCCEEDED(rv) && exists)
 189         array.AppendObject(commonPlugins);
 190   }
 191
 192   nsCOMPtr<nsIPrefBranch> prefs(do_GetService(NS_PREFSERVICE_CONTRACTID));
 193   if (prefs) {
 194
 195     nsCOMPtr<nsIFile> localePlugins;
 196     rv = searchPlugins->Clone(getter_AddRefs(localePlugins));
 197     if (NS_FAILED(rv))
 198       return;
 199
 200     localePlugins->AppendNative(NS_LITERAL_CSTRING("locale"));
 201
 202     nsCString locale;
 203     rv = prefs->GetCharPref("general.useragent.locale", getter_Copies(locale));
 204     if (NS_SUCCEEDED(rv)) {
 205
 206       nsCOMPtr<nsIFile> curLocalePlugins;
 207       rv = localePlugins->Clone(getter_AddRefs(curLocalePlugins));
 208       if (NS_SUCCEEDED(rv)) {
 209
 210         curLocalePlugins->AppendNative(locale);
 211         rv = curLocalePlugins->Exists(&exists);
 212         if (NS_SUCCEEDED(rv) && exists) {
 213           array.AppendObject(curLocalePlugins);
 214           return; // all done
 215         }
 216       }
 217     }
 218
 219     // we didn't append the locale dir - try the default one
 220     nsCString defLocale;
 221     rv = prefs->GetCharPref("distribution.searchplugins.defaultLocale",
 222                             getter_Copies(defLocale));
 223     if (NS_SUCCEEDED(rv)) {
 224
 225       nsCOMPtr<nsIFile> defLocalePlugins;
 226       rv = localePlugins->Clone(getter_AddRefs(defLocalePlugins));
 227       if (NS_SUCCEEDED(rv)) {
 228
 229         defLocalePlugins->AppendNative(defLocale);
 230         rv = defLocalePlugins->Exists(&exists);
 231         if (NS_SUCCEEDED(rv) && exists)
 232           array.AppendObject(defLocalePlugins);
 233       }
 234     }
 235   }
 236 }
 237
 238 NS_IMETHODIMP
 239 DirectoryProvider::GetFiles(const char *aKey, nsISimpleEnumerator* *aResult)
 240 {
 241   nsresult rv;
 242
 243   if (!strcmp(aKey, NS_APP_SEARCH_DIR_LIST)) {
 244     nsCOMPtr<nsIProperties> dirSvc
 245       (do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID));
 246     if (!dirSvc)
 247       return NS_ERROR_FAILURE;
 248
 249     nsCOMArray<nsIFile> baseFiles;
 250
 251     /**
 252      * We want to preserve the following order, since the search service loads
 253      * engines in first-loaded-wins order.
 254      *   - extension search plugin locations (prepended below using
 255      *     NS_NewUnionEnumerator)
 256      *   - distro search plugin locations
 257      *   - user search plugin locations (profile)
 258      *   - app search plugin location (shipped engines)
 259      */
 260     AppendDistroSearchDirs(dirSvc, baseFiles);
 261     AppendFileKey(NS_APP_USER_SEARCH_DIR, dirSvc, baseFiles);
 262     AppendFileKey(NS_APP_SEARCH_DIR, dirSvc, baseFiles);
 263
 264     nsCOMPtr<nsISimpleEnumerator> baseEnum;
 265     rv = NS_NewArrayEnumerator(getter_AddRefs(baseEnum), baseFiles);
 266     if (NS_FAILED(rv))
 267       return rv;
 268
 269     nsCOMPtr<nsISimpleEnumerator> list;
 270     rv = dirSvc->Get(XRE_EXTENSIONS_DIR_LIST,
 271                      NS_GET_IID(nsISimpleEnumerator), getter_AddRefs(list));
 272     if (NS_FAILED(rv))
 273       return rv;
 274
 275     static char const *const kAppendSPlugins[] = {"searchplugins", nsnull};
 276
 277     nsCOMPtr<nsISimpleEnumerator> extEnum =
 278       new AppendingEnumerator(list, kAppendSPlugins);
 279     if (!extEnum)
 280       return NS_ERROR_OUT_OF_MEMORY;
 281
 282     return NS_NewUnionEnumerator(aResult, extEnum, baseEnum);
 283   }
 284
 285   return NS_ERROR_FAILURE;
 286 }
 287
 288 NS_IMPL_ISUPPORTS1(DirectoryProvider::AppendingEnumerator, nsISimpleEnumerator)
 289
 290 NS_IMETHODIMP
 291 DirectoryProvider::AppendingEnumerator::HasMoreElements(bool *aResult)
 292 {
 293   *aResult = mNext ? true : false;
 294   return NS_OK;
 295 }
 296
 297 NS_IMETHODIMP
 298 DirectoryProvider::AppendingEnumerator::GetNext(nsISupports* *aResult)
 299 {
 300   if (aResult)
 301     NS_ADDREF(*aResult = mNext);
 302
 303   mNext = nsnull;
 304
 305   nsresult rv;
 306
 307   // Ignore all errors
 308
 309   bool more;
 310   while (NS_SUCCEEDED(mBase->HasMoreElements(&more)) && more) {
 311     nsCOMPtr<nsISupports> nextbasesupp;
 312     mBase->GetNext(getter_AddRefs(nextbasesupp));
 313
 314     nsCOMPtr<nsIFile> nextbase(do_QueryInterface(nextbasesupp));
 315     if (!nextbase)
 316       continue;
 317
 318     nextbase->Clone(getter_AddRefs(mNext));
 319     if (!mNext)
 320       continue;
 321
 322     char const *const * i = mAppendList;
 323     while (*i) {
 324       mNext->AppendNative(nsDependentCString(*i));
 325       ++i;
 326     }
 327
 328     bool exists;
 329     rv = mNext->Exists(&exists);
 330     if (NS_SUCCEEDED(rv) && exists)
 331       break;
 332
 333     mNext = nsnull;
 334   }
 335
 336   return NS_OK;
 337 }
 338
 339 DirectoryProvider::AppendingEnumerator::AppendingEnumerator
 340     (nsISimpleEnumerator* aBase,
 341      char const *const *aAppendList) :
 342   mBase(aBase),
 343   mAppendList(aAppendList)
 344 {
 345   // Initialize mNext to begin.
 346   GetNext(nsnull);
 347 }
 348
 349 } // namespace browser
 350 } // namespace mozilla