1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "chrome/common/chrome_paths.h" 6 7 #include "base/files/file_util.h" 8 #include "base/lazy_instance.h" 9 #include "base/logging.h" 10 #include "base/mac/bundle_locations.h" 11 #include "base/path_service.h" 12 #include "base/strings/string_util.h" 13 #include "base/sys_info.h" 14 #include "base/threading/thread_restrictions.h" 15 #include "base/version.h" 16 #include "chrome/common/chrome_constants.h" 17 #include "chrome/common/chrome_paths_internal.h" 18 #include "chrome/common/widevine_cdm_constants.h" 19 #include "ui/base/ui_base_paths.h" 20 21 #if defined(OS_ANDROID) 22 #include "base/android/path_utils.h" 23 #include "base/base_paths_android.h" 24 #endif 25 26 #if defined(OS_MACOSX) 27 #include "base/mac/foundation_util.h" 28 #endif 29 30 #include "widevine_cdm_version.h" // In SHARED_INTERMEDIATE_DIR. 31 32 namespace { 33 34 // File name of the internal Flash plugin on different platforms. 35 const base::FilePath::CharType kInternalFlashPluginFileName[] = 36 #if defined(OS_MACOSX) 37 FILE_PATH_LITERAL("Flash Player Plugin for Chrome.plugin"); 38 #elif defined(OS_WIN) 39 FILE_PATH_LITERAL("gcswf32.dll"); 40 #else // OS_LINUX, etc. 41 FILE_PATH_LITERAL("libgcflashplayer.so"); 42 #endif 43 44 // The Pepper Flash plugins are in a directory with this name. 45 const base::FilePath::CharType kPepperFlashBaseDirectory[] = 46 FILE_PATH_LITERAL("PepperFlash"); 47 48 #if defined(OS_WIN) 49 const base::FilePath::CharType kPepperFlashDebuggerBaseDirectory[] = 50 FILE_PATH_LITERAL("Macromed\\Flash"); 51 #endif 52 53 // File name of the internal PDF plugin on different platforms. 54 const base::FilePath::CharType kInternalPDFPluginFileName[] = 55 #if defined(OS_WIN) 56 FILE_PATH_LITERAL("pdf.dll"); 57 #elif defined(OS_MACOSX) 58 FILE_PATH_LITERAL("PDF.plugin"); 59 #else // Linux and Chrome OS 60 FILE_PATH_LITERAL("libpdf.so"); 61 #endif 62 63 const base::FilePath::CharType kInternalNaClPluginFileName[] = 64 FILE_PATH_LITERAL("internal-nacl-plugin"); 65 66 const base::FilePath::CharType kEffectsPluginFileName[] = 67 #if defined(OS_WIN) 68 FILE_PATH_LITERAL("pepper/libppeffects.dll"); 69 #elif defined(OS_MACOSX) 70 FILE_PATH_LITERAL("pepper/libppeffects.plugin"); 71 #else // Linux and Chrome OS 72 FILE_PATH_LITERAL("pepper/libppeffects.so"); 73 #endif 74 75 #if defined(OS_POSIX) && !defined(OS_MACOSX) 76 77 const base::FilePath::CharType kO1DPluginFileName[] = 78 FILE_PATH_LITERAL("pepper/libppo1d.so"); 79 80 const base::FilePath::CharType kGTalkPluginFileName[] = 81 FILE_PATH_LITERAL("pepper/libppgoogletalk.so"); 82 83 #endif // defined(OS_POSIX) && !defined(OS_MACOSX) 84 85 #if defined(OS_LINUX) 86 // The path to the external extension <id>.json files. 87 // /usr/share seems like a good choice, see: http://www.pathname.com/fhs/ 88 const base::FilePath::CharType kFilepathSinglePrefExtensions[] = 89 #if defined(GOOGLE_CHROME_BUILD) 90 FILE_PATH_LITERAL("/usr/share/google-chrome/extensions"); 91 #else 92 FILE_PATH_LITERAL("/usr/share/chromium/extensions"); 93 #endif // defined(GOOGLE_CHROME_BUILD) 94 #endif // defined(OS_LINUX) 95 96 static base::LazyInstance<base::FilePath> 97 g_invalid_specified_user_data_dir = LAZY_INSTANCE_INITIALIZER; 98 99 // Gets the path for internal plugins. 100 bool GetInternalPluginsDirectory(base::FilePath* result) { 101 #if defined(OS_MACOSX) && !defined(OS_IOS) 102 // If called from Chrome, get internal plugins from a subdirectory of the 103 // framework. 104 if (base::mac::AmIBundled()) { 105 *result = chrome::GetFrameworkBundlePath(); 106 DCHECK(!result->empty()); 107 *result = result->Append("Internet Plug-Ins"); 108 return true; 109 } 110 // In tests, just look in the module directory (below). 111 #endif 112 113 // The rest of the world expects plugins in the module directory. 114 return PathService::Get(base::DIR_MODULE, result); 115 } 116 117 } // namespace 118 119 namespace chrome { 120 121 bool PathProvider(int key, base::FilePath* result) { 122 // Some keys are just aliases... 123 switch (key) { 124 case chrome::DIR_APP: 125 return PathService::Get(base::DIR_MODULE, result); 126 case chrome::DIR_LOGS: 127 #ifdef NDEBUG 128 // Release builds write to the data dir 129 return PathService::Get(chrome::DIR_USER_DATA, result); 130 #else 131 // Debug builds write next to the binary (in the build tree) 132 #if defined(OS_MACOSX) 133 if (!PathService::Get(base::DIR_EXE, result)) 134 return false; 135 if (base::mac::AmIBundled()) { 136 // If we're called from chrome, dump it beside the app (outside the 137 // app bundle), if we're called from a unittest, we'll already 138 // outside the bundle so use the exe dir. 139 // exe_dir gave us .../Chromium.app/Contents/MacOS/Chromium. 140 *result = result->DirName(); 141 *result = result->DirName(); 142 *result = result->DirName(); 143 } 144 return true; 145 #else 146 return PathService::Get(base::DIR_EXE, result); 147 #endif // defined(OS_MACOSX) 148 #endif // NDEBUG 149 case chrome::FILE_RESOURCE_MODULE: 150 return PathService::Get(base::FILE_MODULE, result); 151 } 152 153 // Assume that we will not need to create the directory if it does not exist. 154 // This flag can be set to true for the cases where we want to create it. 155 bool create_dir = false; 156 157 base::FilePath cur; 158 switch (key) { 159 case chrome::DIR_USER_DATA: 160 if (!GetDefaultUserDataDirectory(&cur)) { 161 NOTREACHED(); 162 return false; 163 } 164 create_dir = true; 165 break; 166 case chrome::DIR_USER_DOCUMENTS: 167 if (!GetUserDocumentsDirectory(&cur)) 168 return false; 169 create_dir = true; 170 break; 171 case chrome::DIR_USER_MUSIC: 172 if (!GetUserMusicDirectory(&cur)) 173 return false; 174 break; 175 case chrome::DIR_USER_PICTURES: 176 if (!GetUserPicturesDirectory(&cur)) 177 return false; 178 break; 179 case chrome::DIR_USER_VIDEOS: 180 if (!GetUserVideosDirectory(&cur)) 181 return false; 182 break; 183 case chrome::DIR_DEFAULT_DOWNLOADS_SAFE: 184 #if defined(OS_WIN) || defined(OS_LINUX) 185 if (!GetUserDownloadsDirectorySafe(&cur)) 186 return false; 187 break; 188 #else 189 // Fall through for all other platforms. 190 #endif 191 case chrome::DIR_DEFAULT_DOWNLOADS: 192 #if defined(OS_ANDROID) 193 if (!base::android::GetDownloadsDirectory(&cur)) 194 return false; 195 #else 196 if (!GetUserDownloadsDirectory(&cur)) 197 return false; 198 // Do not create the download directory here, we have done it twice now 199 // and annoyed a lot of users. 200 #endif 201 break; 202 case chrome::DIR_CRASH_DUMPS: 203 #if defined(OS_CHROMEOS) 204 // ChromeOS uses a separate directory. See http://crosbug.com/25089 205 cur = base::FilePath("/var/log/chrome"); 206 #elif defined(OS_ANDROID) 207 if (!base::android::GetCacheDirectory(&cur)) 208 return false; 209 #else 210 // The crash reports are always stored relative to the default user data 211 // directory. This avoids the problem of having to re-initialize the 212 // exception handler after parsing command line options, which may 213 // override the location of the app's profile directory. 214 if (!GetDefaultUserDataDirectory(&cur)) 215 return false; 216 #endif 217 cur = cur.Append(FILE_PATH_LITERAL("Crash Reports")); 218 create_dir = true; 219 break; 220 case chrome::DIR_RESOURCES: 221 #if defined(OS_MACOSX) 222 cur = base::mac::FrameworkBundlePath(); 223 cur = cur.Append(FILE_PATH_LITERAL("Resources")); 224 #else 225 if (!PathService::Get(chrome::DIR_APP, &cur)) 226 return false; 227 cur = cur.Append(FILE_PATH_LITERAL("resources")); 228 #endif 229 break; 230 case chrome::DIR_INSPECTOR: 231 if (!PathService::Get(chrome::DIR_RESOURCES, &cur)) 232 return false; 233 cur = cur.Append(FILE_PATH_LITERAL("inspector")); 234 break; 235 case chrome::DIR_APP_DICTIONARIES: 236 #if defined(OS_POSIX) 237 // We can't write into the EXE dir on Linux, so keep dictionaries 238 // alongside the safe browsing database in the user data dir. 239 // And we don't want to write into the bundle on the Mac, so push 240 // it to the user data dir there also. 241 if (!PathService::Get(chrome::DIR_USER_DATA, &cur)) 242 return false; 243 #else 244 if (!PathService::Get(base::DIR_EXE, &cur)) 245 return false; 246 #endif 247 cur = cur.Append(FILE_PATH_LITERAL("Dictionaries")); 248 create_dir = true; 249 break; 250 case chrome::DIR_INTERNAL_PLUGINS: 251 if (!GetInternalPluginsDirectory(&cur)) 252 return false; 253 break; 254 case chrome::DIR_PEPPER_FLASH_PLUGIN: 255 if (!GetInternalPluginsDirectory(&cur)) 256 return false; 257 cur = cur.Append(kPepperFlashBaseDirectory); 258 break; 259 case chrome::DIR_COMPONENT_UPDATED_PEPPER_FLASH_PLUGIN: 260 if (!PathService::Get(chrome::DIR_USER_DATA, &cur)) 261 return false; 262 cur = cur.Append(kPepperFlashBaseDirectory); 263 break; 264 case chrome::DIR_PEPPER_FLASH_DEBUGGER_PLUGIN: 265 #if defined(OS_WIN) 266 if (!PathService::Get(base::DIR_SYSTEM, &cur)) 267 return false; 268 cur = cur.Append(kPepperFlashDebuggerBaseDirectory); 269 #elif defined(OS_MACOSX) 270 // TODO(luken): finalize Mac OS directory paths, current consensus is 271 // around /Library/Internet Plug-Ins/PepperFlashPlayer/ 272 return false; 273 #else 274 return false; 275 #endif 276 break; 277 case chrome::FILE_LOCAL_STATE: 278 if (!PathService::Get(chrome::DIR_USER_DATA, &cur)) 279 return false; 280 cur = cur.Append(chrome::kLocalStateFilename); 281 break; 282 case chrome::FILE_RECORDED_SCRIPT: 283 if (!PathService::Get(chrome::DIR_USER_DATA, &cur)) 284 return false; 285 cur = cur.Append(FILE_PATH_LITERAL("script.log")); 286 break; 287 case chrome::FILE_FLASH_PLUGIN: 288 if (!GetInternalPluginsDirectory(&cur)) 289 return false; 290 cur = cur.Append(kInternalFlashPluginFileName); 291 break; 292 case chrome::FILE_PEPPER_FLASH_PLUGIN: 293 if (!PathService::Get(chrome::DIR_PEPPER_FLASH_PLUGIN, &cur)) 294 return false; 295 cur = cur.Append(chrome::kPepperFlashPluginFilename); 296 break; 297 case chrome::FILE_PDF_PLUGIN: 298 if (!GetInternalPluginsDirectory(&cur)) 299 return false; 300 cur = cur.Append(kInternalPDFPluginFileName); 301 break; 302 case chrome::FILE_EFFECTS_PLUGIN: 303 if (!GetInternalPluginsDirectory(&cur)) 304 return false; 305 cur = cur.Append(kEffectsPluginFileName); 306 break; 307 // TODO(teravest): Remove this case once the internal NaCl plugin is gone. 308 // We currently need a path here to look up whether the plugin is disabled 309 // and what its permissions are. 310 case chrome::FILE_NACL_PLUGIN: 311 if (!GetInternalPluginsDirectory(&cur)) 312 return false; 313 cur = cur.Append(kInternalNaClPluginFileName); 314 break; 315 // PNaCl is currenly installable via the component updater or by being 316 // simply built-in. DIR_PNACL_BASE is used as the base directory for 317 // installation via component updater. DIR_PNACL_COMPONENT will be 318 // the final location of pnacl, which is a subdir of DIR_PNACL_BASE. 319 case chrome::DIR_PNACL_BASE: 320 if (!PathService::Get(chrome::DIR_USER_DATA, &cur)) 321 return false; 322 cur = cur.Append(FILE_PATH_LITERAL("pnacl")); 323 break; 324 // Where PNaCl files are ultimately located. The default finds the files 325 // inside the InternalPluginsDirectory / build directory, as if it 326 // was shipped along with chrome. The value can be overridden 327 // if it is installed via component updater. 328 case chrome::DIR_PNACL_COMPONENT: 329 #if defined(OS_MACOSX) 330 // PNaCl really belongs in the InternalPluginsDirectory but actually 331 // copying it there would result in the files also being shipped, which 332 // we don't want yet. So for now, just find them in the directory where 333 // they get built. 334 if (!PathService::Get(base::DIR_EXE, &cur)) 335 return false; 336 if (base::mac::AmIBundled()) { 337 // If we're called from chrome, it's beside the app (outside the 338 // app bundle), if we're called from a unittest, we'll already be 339 // outside the bundle so use the exe dir. 340 // exe_dir gave us .../Chromium.app/Contents/MacOS/Chromium. 341 cur = cur.DirName(); 342 cur = cur.DirName(); 343 cur = cur.DirName(); 344 } 345 #else 346 if (!GetInternalPluginsDirectory(&cur)) 347 return false; 348 #endif 349 cur = cur.Append(FILE_PATH_LITERAL("pnacl")); 350 break; 351 #if defined(OS_POSIX) && !defined(OS_MACOSX) 352 case chrome::FILE_O1D_PLUGIN: 353 if (!PathService::Get(base::DIR_MODULE, &cur)) 354 return false; 355 cur = cur.Append(kO1DPluginFileName); 356 break; 357 case chrome::FILE_GTALK_PLUGIN: 358 if (!PathService::Get(base::DIR_MODULE, &cur)) 359 return false; 360 cur = cur.Append(kGTalkPluginFileName); 361 break; 362 #endif 363 #if defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS) 364 #if defined(WIDEVINE_CDM_IS_COMPONENT) 365 case chrome::DIR_COMPONENT_WIDEVINE_CDM: 366 if (!PathService::Get(chrome::DIR_USER_DATA, &cur)) 367 return false; 368 cur = cur.Append(kWidevineCdmBaseDirectory); 369 break; 370 #endif // defined(WIDEVINE_CDM_IS_COMPONENT) 371 // TODO(xhwang): FILE_WIDEVINE_CDM_ADAPTER has different meanings. 372 // In the component case, this is the source adapter. Otherwise, it is the 373 // actual Pepper module that gets loaded. 374 case chrome::FILE_WIDEVINE_CDM_ADAPTER: 375 if (!GetInternalPluginsDirectory(&cur)) 376 return false; 377 cur = cur.AppendASCII(kWidevineCdmAdapterFileName); 378 break; 379 #endif // defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS) 380 case chrome::FILE_RESOURCES_PACK: 381 #if defined(OS_MACOSX) && !defined(OS_IOS) 382 if (base::mac::AmIBundled()) { 383 cur = base::mac::FrameworkBundlePath(); 384 cur = cur.Append(FILE_PATH_LITERAL("Resources")) 385 .Append(FILE_PATH_LITERAL("resources.pak")); 386 break; 387 } 388 #elif defined(OS_ANDROID) 389 if (!PathService::Get(ui::DIR_RESOURCE_PAKS_ANDROID, &cur)) 390 return false; 391 #else 392 // If we're not bundled on mac or Android, resources.pak should be next 393 // to the binary (e.g., for unit tests). 394 if (!PathService::Get(base::DIR_MODULE, &cur)) 395 return false; 396 #endif 397 cur = cur.Append(FILE_PATH_LITERAL("resources.pak")); 398 break; 399 case chrome::DIR_RESOURCES_EXTENSION: 400 if (!PathService::Get(base::DIR_MODULE, &cur)) 401 return false; 402 cur = cur.Append(FILE_PATH_LITERAL("resources")) 403 .Append(FILE_PATH_LITERAL("extension")); 404 break; 405 #if defined(OS_CHROMEOS) 406 case chrome::DIR_CHROMEOS_WALLPAPERS: 407 if (!PathService::Get(chrome::DIR_USER_DATA, &cur)) 408 return false; 409 cur = cur.Append(FILE_PATH_LITERAL("wallpapers")); 410 break; 411 case chrome::DIR_CHROMEOS_WALLPAPER_THUMBNAILS: 412 if (!PathService::Get(chrome::DIR_USER_DATA, &cur)) 413 return false; 414 cur = cur.Append(FILE_PATH_LITERAL("wallpaper_thumbnails")); 415 break; 416 case chrome::DIR_CHROMEOS_CUSTOM_WALLPAPERS: 417 if (!PathService::Get(chrome::DIR_USER_DATA, &cur)) 418 return false; 419 cur = cur.Append(FILE_PATH_LITERAL("custom_wallpapers")); 420 break; 421 #endif 422 #if defined(OS_LINUX) && defined(ENABLE_MANAGED_USERS) 423 case chrome::DIR_SUPERVISED_USERS_DEFAULT_APPS: 424 if (!PathService::Get(chrome::DIR_STANDALONE_EXTERNAL_EXTENSIONS, &cur)) 425 return false; 426 cur = cur.Append(FILE_PATH_LITERAL("managed_users")); 427 break; 428 #endif 429 // The following are only valid in the development environment, and 430 // will fail if executed from an installed executable (because the 431 // generated path won't exist). 432 case chrome::DIR_GEN_TEST_DATA: 433 #if defined(OS_ANDROID) 434 // On Android, our tests don't have permission to write to DIR_MODULE. 435 // gtest/test_runner.py pushes data to external storage. 436 if (!PathService::Get(base::DIR_ANDROID_EXTERNAL_STORAGE, &cur)) 437 return false; 438 #else 439 if (!PathService::Get(base::DIR_MODULE, &cur)) 440 return false; 441 #endif 442 cur = cur.Append(FILE_PATH_LITERAL("test_data")); 443 if (!base::PathExists(cur)) // We don't want to create this. 444 return false; 445 break; 446 case chrome::DIR_TEST_DATA: 447 if (!PathService::Get(base::DIR_SOURCE_ROOT, &cur)) 448 return false; 449 cur = cur.Append(FILE_PATH_LITERAL("chrome")); 450 cur = cur.Append(FILE_PATH_LITERAL("test")); 451 cur = cur.Append(FILE_PATH_LITERAL("data")); 452 if (!base::PathExists(cur)) // We don't want to create this. 453 return false; 454 break; 455 case chrome::DIR_TEST_TOOLS: 456 if (!PathService::Get(base::DIR_SOURCE_ROOT, &cur)) 457 return false; 458 cur = cur.Append(FILE_PATH_LITERAL("chrome")); 459 cur = cur.Append(FILE_PATH_LITERAL("tools")); 460 cur = cur.Append(FILE_PATH_LITERAL("test")); 461 if (!base::PathExists(cur)) // We don't want to create this 462 return false; 463 break; 464 #if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_OPENBSD) 465 case chrome::DIR_POLICY_FILES: { 466 #if defined(GOOGLE_CHROME_BUILD) 467 cur = base::FilePath(FILE_PATH_LITERAL("/etc/opt/chrome/policies")); 468 #else 469 cur = base::FilePath(FILE_PATH_LITERAL("/etc/chromium/policies")); 470 #endif 471 break; 472 } 473 #endif 474 #if defined(OS_MACOSX) && !defined(OS_IOS) 475 case chrome::DIR_MANAGED_PREFS: { 476 if (!GetLocalLibraryDirectory(&cur)) 477 return false; 478 cur = cur.Append(FILE_PATH_LITERAL("Managed Preferences")); 479 char* login = getlogin(); 480 if (!login) 481 return false; 482 cur = cur.AppendASCII(login); 483 if (!base::PathExists(cur)) // We don't want to create this. 484 return false; 485 break; 486 } 487 case chrome::DIR_USER_LIBRARY: { 488 if (!GetUserLibraryDirectory(&cur)) 489 return false; 490 if (!base::PathExists(cur)) // We don't want to create this. 491 return false; 492 break; 493 } 494 case chrome::DIR_USER_APPLICATIONS: { 495 if (!GetUserApplicationsDirectory(&cur)) 496 return false; 497 if (!base::PathExists(cur)) // We don't want to create this. 498 return false; 499 break; 500 } 501 #endif 502 #if defined(OS_CHROMEOS) || (defined(OS_MACOSX) && !defined(OS_IOS)) 503 case chrome::DIR_USER_EXTERNAL_EXTENSIONS: { 504 if (!PathService::Get(chrome::DIR_USER_DATA, &cur)) 505 return false; 506 cur = cur.Append(FILE_PATH_LITERAL("External Extensions")); 507 break; 508 } 509 #endif 510 #if defined(OS_LINUX) 511 case chrome::DIR_STANDALONE_EXTERNAL_EXTENSIONS: { 512 cur = base::FilePath(kFilepathSinglePrefExtensions); 513 break; 514 } 515 #endif 516 case chrome::DIR_EXTERNAL_EXTENSIONS: 517 #if defined(OS_MACOSX) && !defined(OS_IOS) 518 if (!chrome::GetGlobalApplicationSupportDirectory(&cur)) 519 return false; 520 521 cur = cur.Append(FILE_PATH_LITERAL("Google")) 522 .Append(FILE_PATH_LITERAL("Chrome")) 523 .Append(FILE_PATH_LITERAL("External Extensions")); 524 create_dir = false; 525 #else 526 if (!PathService::Get(base::DIR_MODULE, &cur)) 527 return false; 528 529 cur = cur.Append(FILE_PATH_LITERAL("extensions")); 530 create_dir = true; 531 #endif 532 break; 533 534 case chrome::DIR_DEFAULT_APPS: 535 #if defined(OS_MACOSX) 536 cur = base::mac::FrameworkBundlePath(); 537 cur = cur.Append(FILE_PATH_LITERAL("Default Apps")); 538 #else 539 if (!PathService::Get(chrome::DIR_APP, &cur)) 540 return false; 541 cur = cur.Append(FILE_PATH_LITERAL("default_apps")); 542 #endif 543 break; 544 545 #if defined(OS_LINUX) || (defined(OS_MACOSX) && !defined(OS_IOS)) 546 case chrome::DIR_NATIVE_MESSAGING: 547 #if defined(OS_MACOSX) 548 #if defined(GOOGLE_CHROME_BUILD) 549 cur = base::FilePath(FILE_PATH_LITERAL( 550 "/Library/Google/Chrome/NativeMessagingHosts")); 551 #else 552 cur = base::FilePath(FILE_PATH_LITERAL( 553 "/Library/Application Support/Chromium/NativeMessagingHosts")); 554 #endif 555 #else // defined(OS_MACOSX) 556 #if defined(GOOGLE_CHROME_BUILD) 557 cur = base::FilePath(FILE_PATH_LITERAL( 558 "/etc/opt/chrome/native-messaging-hosts")); 559 #else 560 cur = base::FilePath(FILE_PATH_LITERAL( 561 "/etc/chromium/native-messaging-hosts")); 562 #endif 563 #endif // !defined(OS_MACOSX) 564 break; 565 566 case chrome::DIR_USER_NATIVE_MESSAGING: 567 if (!PathService::Get(chrome::DIR_USER_DATA, &cur)) 568 return false; 569 cur = cur.Append(FILE_PATH_LITERAL("NativeMessagingHosts")); 570 break; 571 #endif // defined(OS_LINUX) || (defined(OS_MACOSX) && !defined(OS_IOS)) 572 #if !defined(OS_ANDROID) 573 case chrome::DIR_GLOBAL_GCM_STORE: 574 if (!PathService::Get(chrome::DIR_USER_DATA, &cur)) 575 return false; 576 cur = cur.Append(kGCMStoreDirname); 577 break; 578 #endif // !defined(OS_ANDROID) 579 580 default: 581 return false; 582 } 583 584 // TODO(bauerb): http://crbug.com/259796 585 base::ThreadRestrictions::ScopedAllowIO allow_io; 586 if (create_dir && !base::PathExists(cur) && 587 !base::CreateDirectory(cur)) 588 return false; 589 590 *result = cur; 591 return true; 592 } 593 594 // This cannot be done as a static initializer sadly since Visual Studio will 595 // eliminate this object file if there is no direct entry point into it. 596 void RegisterPathProvider() { 597 PathService::RegisterProvider(PathProvider, PATH_START, PATH_END); 598 } 599 600 void SetInvalidSpecifiedUserDataDir(const base::FilePath& user_data_dir) { 601 g_invalid_specified_user_data_dir.Get() = user_data_dir; 602 } 603 604 const base::FilePath& GetInvalidSpecifiedUserDataDir() { 605 return g_invalid_specified_user_data_dir.Get(); 606 } 607 608 } // namespace chrome 609
