Thanks to visit codestin.com
Credit goes to chromium.googlesource.com

Google Git
Sign in
chromium / chromium / src / main / . / base / path_service.cc
blob: c6a1855428bb6ebb2287a45e6a14a81b0d0f3f46 [file] [log] [blame]
Avi Drissmane4622aa2022-09-08 20:36:06[diff] [blame]1// Copyright 2012 The Chromium Authors
license.botbf09a502008-08-24 00:55:55[diff] [blame]2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]4
[email protected]09ad1e622008-08-07 20:23:09[diff] [blame]5#include "base/path_service.h"
[email protected]355cc2742008-08-06 16:01:25[diff] [blame]6
brettw1ce49f62017-04-27 19:42:32[diff] [blame]7#include <unordered_map>
Greg Thompson53fd47592023-08-01 07:30:59[diff] [blame]8#include <utility>
brettw1ce49f62017-04-27 19:42:32[diff] [blame]9
Qi Tiezhengf537c422022-09-15 06:58:34[diff] [blame]10#include "base/check_op.h"
11#include "base/files/file_path.h"
12#include "base/files/file_util.h"
13#include "base/logging.h"
Keishi Hattori0e45c022021-11-27 09:25:52[diff] [blame]14#include "base/memory/raw_ptr.h"
Keishi Hattori8a7e15d2023-01-19 07:16:29[diff] [blame]15#include "base/memory/raw_ptr_exclusion.h"
Qi Tiezhengf537c422022-09-15 06:58:34[diff] [blame]16#include "base/synchronization/lock.h"
Xiaohan Wang38e4ebb2022-01-19 06:57:43[diff] [blame]17#include "build/build_config.h"
Keishi Hattori0e45c022021-11-27 09:25:52[diff] [blame]18
Xiaohan Wang38e4ebb2022-01-19 06:57:43[diff] [blame]19#if BUILDFLAG(IS_WIN)
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]20#include <windows.h>
Bruce Dawsona1e1cfcb2022-11-22 20:04:35[diff] [blame]21
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]22#include <shellapi.h>
23#include <shlobj.h>
[email protected]355cc2742008-08-06 16:01:25[diff] [blame]24#endif
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]25
Paul Semelf90c9dc52023-11-03 12:19:56[diff] [blame]26#define ENABLE_BEHAVIOUR_OVERRIDE_PROVIDER \
27 ((BUILDFLAG(IS_POSIX) && !BUILDFLAG(IS_APPLE) && !BUILDFLAG(IS_ANDROID)) || \
28 BUILDFLAG(IS_WIN))
29
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]30namespace base {
brettwf0dea132015-09-25 20:08:54[diff] [blame]31
Paul Semelf90c9dc52023-11-03 12:19:56[diff] [blame]32// Custom behaviour providers.
33bool EnvOverridePathProvider(int key, FilePath* result);
34
brettwf0dea132015-09-25 20:08:54[diff] [blame]35bool PathProvider(int key, FilePath* result);
36
Xiaohan Wang38e4ebb2022-01-19 06:57:43[diff] [blame]37#if BUILDFLAG(IS_WIN)
brettwf0dea132015-09-25 20:08:54[diff] [blame]38bool PathProviderWin(int key, FilePath* result);
Sylvain Defresnea9ffa992023-06-19 09:29:06[diff] [blame]39#elif BUILDFLAG(IS_MAC)
brettwf0dea132015-09-25 20:08:54[diff] [blame]40bool PathProviderMac(int key, FilePath* result);
Sylvain Defresnea9ffa992023-06-19 09:29:06[diff] [blame]41#elif BUILDFLAG(IS_IOS)
42bool PathProviderIOS(int key, FilePath* result);
Xiaohan Wang38e4ebb2022-01-19 06:57:43[diff] [blame]43#elif BUILDFLAG(IS_ANDROID)
brettwf0dea132015-09-25 20:08:54[diff] [blame]44bool PathProviderAndroid(int key, FilePath* result);
Xiaohan Wang38e4ebb2022-01-19 06:57:43[diff] [blame]45#elif BUILDFLAG(IS_FUCHSIA)
scottmg1ab7aa82017-05-25 05:22:49[diff] [blame]46bool PathProviderFuchsia(int key, FilePath* result);
Xiaohan Wang38e4ebb2022-01-19 06:57:43[diff] [blame]47#elif BUILDFLAG(IS_POSIX)
brettwf0dea132015-09-25 20:08:54[diff] [blame]48// PathProviderPosix is the default path provider on POSIX OSes other than
49// Mac and Android.
50bool PathProviderPosix(int key, FilePath* result);
[email protected]ac510e12008-08-05 19:46:31[diff] [blame]51#endif
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]52
53namespace {
54
brettw1ce49f62017-04-27 19:42:32[diff] [blame]55typedef std::unordered_map<int, FilePath> PathMap;
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]56
57// We keep a linked list of providers. In a debug build we ensure that no two
58// providers claim overlapping keys.
59struct Provider {
60 PathService::ProviderFunc func;
Devon Loehrde99c7302024-12-16 21:33:05[diff] [blame]61 // This field is not a raw_ptr<> because would cause the class to have a
62 // nontrivial destructor, causing several cascading compile errors. The
63 // pointer cannot dangle because all Providers are either in statically-
64 // allocated memory (globals), or allocated in RegisterProvider and
65 // never freed.
Keishi Hattori8a7e15d2023-01-19 07:16:29[diff] [blame]66 RAW_PTR_EXCLUSION struct Provider* next;
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]67#ifndef NDEBUG
68 int key_start;
69 int key_end;
70#endif
[email protected]173cb8a02008-08-20 15:47:39[diff] [blame]71 bool is_static;
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]72};
73
Ivan Kotenkova16212a52017-11-08 12:37:33[diff] [blame]74Provider base_provider = {PathProvider, nullptr,
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]75#ifndef NDEBUG
Ivan Kotenkova16212a52017-11-08 12:37:33[diff] [blame]76 PATH_START, PATH_END,
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]77#endif
Ivan Kotenkova16212a52017-11-08 12:37:33[diff] [blame]78 true};
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]79
Xiaohan Wang38e4ebb2022-01-19 06:57:43[diff] [blame]80#if BUILDFLAG(IS_WIN)
Paul Semelf90c9dc52023-11-03 12:19:56[diff] [blame]81Provider win_provider = {PathProviderWin, &base_provider,
[email protected]ac510e12008-08-05 19:46:31[diff] [blame]82#ifndef NDEBUG
Paul Semelf90c9dc52023-11-03 12:19:56[diff] [blame]83 PATH_WIN_START, PATH_WIN_END,
[email protected]ac510e12008-08-05 19:46:31[diff] [blame]84#endif
Paul Semelf90c9dc52023-11-03 12:19:56[diff] [blame]85 true};
86Provider base_provider_win = {EnvOverridePathProvider, &win_provider,
87#ifndef NDEBUG
88 PATH_START, PATH_END,
89#endif
90 true};
[email protected]ac510e12008-08-05 19:46:31[diff] [blame]91#endif
92
Sylvain Defresnea9ffa992023-06-19 09:29:06[diff] [blame]93#if BUILDFLAG(IS_MAC)
Peter Kasting134ef9af2024-12-28 02:30:09[diff] [blame]94Provider base_provider_mac = {PathProviderMac, &base_provider,
[email protected]5af2edb92008-08-08 20:16:08[diff] [blame]95#ifndef NDEBUG
Peter Kasting134ef9af2024-12-28 02:30:09[diff] [blame]96 PATH_MAC_START, PATH_MAC_END,
[email protected]5af2edb92008-08-08 20:16:08[diff] [blame]97#endif
Peter Kasting134ef9af2024-12-28 02:30:09[diff] [blame]98 true};
[email protected]5af2edb92008-08-08 20:16:08[diff] [blame]99#endif
[email protected]4c0040c2008-08-15 01:04:11[diff] [blame]100
Sylvain Defresnea9ffa992023-06-19 09:29:06[diff] [blame]101#if BUILDFLAG(IS_IOS)
Peter Kasting134ef9af2024-12-28 02:30:09[diff] [blame]102Provider base_provider_ios = {PathProviderIOS, &base_provider,
Sylvain Defresnea9ffa992023-06-19 09:29:06[diff] [blame]103#ifndef NDEBUG
Peter Kasting134ef9af2024-12-28 02:30:09[diff] [blame]104 PATH_IOS_START, PATH_IOS_END,
Sylvain Defresnea9ffa992023-06-19 09:29:06[diff] [blame]105#endif
Peter Kasting134ef9af2024-12-28 02:30:09[diff] [blame]106 true};
Sylvain Defresnea9ffa992023-06-19 09:29:06[diff] [blame]107#endif
108
Xiaohan Wang38e4ebb2022-01-19 06:57:43[diff] [blame]109#if BUILDFLAG(IS_ANDROID)
Peter Kasting134ef9af2024-12-28 02:30:09[diff] [blame]110Provider base_provider_android = {PathProviderAndroid, &base_provider,
[email protected]f7d69972011-06-21 22:34:50[diff] [blame]111#ifndef NDEBUG
Peter Kasting134ef9af2024-12-28 02:30:09[diff] [blame]112 PATH_ANDROID_START, PATH_ANDROID_END,
[email protected]f7d69972011-06-21 22:34:50[diff] [blame]113#endif
Peter Kasting134ef9af2024-12-28 02:30:09[diff] [blame]114 true};
[email protected]f7d69972011-06-21 22:34:50[diff] [blame]115#endif
116
Xiaohan Wang38e4ebb2022-01-19 06:57:43[diff] [blame]117#if BUILDFLAG(IS_FUCHSIA)
scottmg1ab7aa82017-05-25 05:22:49[diff] [blame]118Provider base_provider_fuchsia = {PathProviderFuchsia, &base_provider,
119#ifndef NDEBUG
120 0, 0,
121#endif
122 true};
123#endif
124
Xiaohan Wang38e4ebb2022-01-19 06:57:43[diff] [blame]125#if BUILDFLAG(IS_POSIX) && !BUILDFLAG(IS_APPLE) && !BUILDFLAG(IS_ANDROID)
Paul Semelf90c9dc52023-11-03 12:19:56[diff] [blame]126Provider posix_provider = {PathProviderPosix, &base_provider,
[email protected]4c0040c2008-08-15 01:04:11[diff] [blame]127#ifndef NDEBUG
Paul Semelf90c9dc52023-11-03 12:19:56[diff] [blame]128 PATH_POSIX_START, PATH_POSIX_END,
[email protected]4c0040c2008-08-15 01:04:11[diff] [blame]129#endif
Paul Semelf90c9dc52023-11-03 12:19:56[diff] [blame]130 true};
131Provider base_provider_posix = {EnvOverridePathProvider, &posix_provider,
132#ifndef NDEBUG
133 PATH_START, PATH_END,
134#endif
135 true};
[email protected]4c0040c2008-08-15 01:04:11[diff] [blame]136#endif
137
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]138struct PathData {
brettwf0dea132015-09-25 20:08:54[diff] [blame]139 Lock lock;
Peter Kasting134ef9af2024-12-28 02:30:09[diff] [blame]140 PathMap cache; // Cache mappings from path key to path value.
141 PathMap overrides; // Track path overrides.
Keishi Hattori0e45c022021-11-27 09:25:52[diff] [blame]142 raw_ptr<Provider> providers; // Linked list of path service providers.
Peter Kasting811504a72025-01-09 03:18:50[diff] [blame]143 bool cache_disabled = false; // Don't use cache if true;
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]144
Peter Kasting811504a72025-01-09 03:18:50[diff] [blame]145 PathData() {
Xiaohan Wang38e4ebb2022-01-19 06:57:43[diff] [blame]146#if BUILDFLAG(IS_WIN)
[email protected]ac510e12008-08-05 19:46:31[diff] [blame]147 providers = &base_provider_win;
Sylvain Defresnea9ffa992023-06-19 09:29:06[diff] [blame]148#elif BUILDFLAG(IS_MAC)
[email protected]5af2edb92008-08-08 20:16:08[diff] [blame]149 providers = &base_provider_mac;
Sylvain Defresnea9ffa992023-06-19 09:29:06[diff] [blame]150#elif BUILDFLAG(IS_IOS)
151 providers = &base_provider_ios;
Xiaohan Wang38e4ebb2022-01-19 06:57:43[diff] [blame]152#elif BUILDFLAG(IS_ANDROID)
[email protected]f7d69972011-06-21 22:34:50[diff] [blame]153 providers = &base_provider_android;
Xiaohan Wang38e4ebb2022-01-19 06:57:43[diff] [blame]154#elif BUILDFLAG(IS_FUCHSIA)
scottmg1ab7aa82017-05-25 05:22:49[diff] [blame]155 providers = &base_provider_fuchsia;
Xiaohan Wang38e4ebb2022-01-19 06:57:43[diff] [blame]156#elif BUILDFLAG(IS_POSIX)
[email protected]5d1937bb2009-11-21 01:29:00[diff] [blame]157 providers = &base_provider_posix;
[email protected]ac510e12008-08-05 19:46:31[diff] [blame]158#endif
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]159 }
160};
[email protected]52a261f2009-03-03 15:01:12[diff] [blame]161
[email protected]1265917f2008-08-12 17:33:52[diff] [blame]162static PathData* GetPathData() {
vmpstr5f02eae2017-02-13 21:11:41[diff] [blame]163 static auto* path_data = new PathData();
scottmg6ece5ae2017-02-01 18:25:19[diff] [blame]164 return path_data;
[email protected]1265917f2008-08-12 17:33:52[diff] [blame]165}
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]166
Benoit Lize25859152020-07-09 11:52:09[diff] [blame]167// Tries to find |key| in the cache.
168bool LockedGetFromCache(int key, const PathData* path_data, FilePath* result)
169 EXCLUSIVE_LOCKS_REQUIRED(path_data->lock) {
Peter Kasting134ef9af2024-12-28 02:30:09[diff] [blame]170 if (path_data->cache_disabled) {
[email protected]c5a726b32013-01-29 00:56:56[diff] [blame]171 return false;
Peter Kasting134ef9af2024-12-28 02:30:09[diff] [blame]172 }
[email protected]6723f832008-08-11 15:38:27[diff] [blame]173 // check for a cached version
jdoerrie1c4b8ff2018-10-03 00:10:57[diff] [blame]174 auto it = path_data->cache.find(key);
[email protected]6723f832008-08-11 15:38:27[diff] [blame]175 if (it != path_data->cache.end()) {
176 *result = it->second;
177 return true;
178 }
179 return false;
180}
181
Benoit Lize25859152020-07-09 11:52:09[diff] [blame]182// Tries to find |key| in the overrides map.
183bool LockedGetFromOverrides(int key, PathData* path_data, FilePath* result)
184 EXCLUSIVE_LOCKS_REQUIRED(path_data->lock) {
[email protected]846c3ecea2011-12-14 18:47:26[diff] [blame]185 // check for an overridden version.
[email protected]34e043b2010-09-09 23:49:04[diff] [blame]186 PathMap::const_iterator it = path_data->overrides.find(key);
187 if (it != path_data->overrides.end()) {
Peter Kasting134ef9af2024-12-28 02:30:09[diff] [blame]188 if (!path_data->cache_disabled) {
[email protected]c5a726b32013-01-29 00:56:56[diff] [blame]189 path_data->cache[key] = it->second;
Peter Kasting134ef9af2024-12-28 02:30:09[diff] [blame]190 }
[email protected]34e043b2010-09-09 23:49:04[diff] [blame]191 *result = it->second;
192 return true;
193 }
194 return false;
195}
196
[email protected]d6b3af92012-09-26 19:05:12[diff] [blame]197} // namespace
[email protected]6723f832008-08-11 15:38:27[diff] [blame]198
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]199// TODO(brettw): this function does not handle long paths (filename > MAX_PATH)
200// characters). This isn't supported very well by Windows right now, so it is
201// moot, but we should keep this in mind for the future.
202// static
[email protected]640517f2008-10-30 23:54:04[diff] [blame]203bool PathService::Get(int key, FilePath* result) {
[email protected]1265917f2008-08-12 17:33:52[diff] [blame]204 PathData* path_data = GetPathData();
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]205 DCHECK(path_data);
206 DCHECK(result);
David Dorwin15b9e1662021-11-04 19:45:05[diff] [blame]207 DCHECK_GT(key, PATH_START);
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]208
David Dorwin15b9e1662021-11-04 19:45:05[diff] [blame]209 // Special case the current directory because it can never be cached.
Peter Kasting134ef9af2024-12-28 02:30:09[diff] [blame]210 if (key == DIR_CURRENT) {
brettwf0dea132015-09-25 20:08:54[diff] [blame]211 return GetCurrentDirectory(result);
Peter Kasting134ef9af2024-12-28 02:30:09[diff] [blame]212 }
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]213
Ivan Kotenkova16212a52017-11-08 12:37:33[diff] [blame]214 Provider* provider = nullptr;
[email protected]d6b3af92012-09-26 19:05:12[diff] [blame]215 {
brettwf0dea132015-09-25 20:08:54[diff] [blame]216 AutoLock scoped_lock(path_data->lock);
Peter Kasting134ef9af2024-12-28 02:30:09[diff] [blame]217 if (LockedGetFromCache(key, path_data, result)) {
[email protected]d6b3af92012-09-26 19:05:12[diff] [blame]218 return true;
Peter Kasting134ef9af2024-12-28 02:30:09[diff] [blame]219 }
[email protected]c1a9f8d42009-02-28 01:49:55[diff] [blame]220
Peter Kasting134ef9af2024-12-28 02:30:09[diff] [blame]221 if (LockedGetFromOverrides(key, path_data, result)) {
[email protected]d6b3af92012-09-26 19:05:12[diff] [blame]222 return true;
Peter Kasting134ef9af2024-12-28 02:30:09[diff] [blame]223 }
[email protected]d6b3af92012-09-26 19:05:12[diff] [blame]224
225 // Get the beginning of the list while it is still locked.
226 provider = path_data->providers;
227 }
[email protected]34e043b2010-09-09 23:49:04[diff] [blame]228
[email protected]4792a262008-11-19 16:50:03[diff] [blame]229 FilePath path;
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]230
[email protected]d6b3af92012-09-26 19:05:12[diff] [blame]231 // Iterating does not need the lock because only the list head might be
232 // modified on another thread.
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]233 while (provider) {
Peter Kasting134ef9af2024-12-28 02:30:09[diff] [blame]234 if (provider->func(key, &path)) {
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]235 break;
Peter Kasting134ef9af2024-12-28 02:30:09[diff] [blame]236 }
[email protected]c1a9f8d42009-02-28 01:49:55[diff] [blame]237 DCHECK(path.empty()) << "provider should not have modified path";
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]238 provider = provider->next;
239 }
240
Peter Kasting134ef9af2024-12-28 02:30:09[diff] [blame]241 if (path.empty()) {
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]242 return false;
Peter Kasting134ef9af2024-12-28 02:30:09[diff] [blame]243 }
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]244
[email protected]082f8202013-01-26 04:51:29[diff] [blame]245 if (path.ReferencesParent()) {
246 // Make sure path service never returns a path with ".." in it.
[email protected]154769362013-04-12 05:17:15[diff] [blame]247 path = MakeAbsoluteFilePath(path);
Peter Kasting134ef9af2024-12-28 02:30:09[diff] [blame]248 if (path.empty()) {
[email protected]082f8202013-01-26 04:51:29[diff] [blame]249 return false;
Peter Kasting134ef9af2024-12-28 02:30:09[diff] [blame]250 }
[email protected]082f8202013-01-26 04:51:29[diff] [blame]251 }
[email protected]640517f2008-10-30 23:54:04[diff] [blame]252 *result = path;
[email protected]d6b3af92012-09-26 19:05:12[diff] [blame]253
brettwf0dea132015-09-25 20:08:54[diff] [blame]254 AutoLock scoped_lock(path_data->lock);
Peter Kasting134ef9af2024-12-28 02:30:09[diff] [blame]255 if (!path_data->cache_disabled) {
[email protected]c5a726b32013-01-29 00:56:56[diff] [blame]256 path_data->cache[key] = path;
Peter Kasting134ef9af2024-12-28 02:30:09[diff] [blame]257 }
[email protected]d6b3af92012-09-26 19:05:12[diff] [blame]258
[email protected]640517f2008-10-30 23:54:04[diff] [blame]259 return true;
260}
261
Maksim Ivanov9a39401c2020-07-08 19:30:37[diff] [blame]262FilePath PathService::CheckedGet(int key) {
263 FilePath path;
Maksim Ivanoveeb2d0802020-07-17 21:44:00[diff] [blame]264 LOG_IF(FATAL, !Get(key, &path)) << "Failed to get the path for " << key;
Maksim Ivanov9a39401c2020-07-08 19:30:37[diff] [blame]265 return path;
266}
267
[email protected]d6b3af92012-09-26 19:05:12[diff] [blame]268// static
[email protected]eca6a4f2009-06-25 17:29:09[diff] [blame]269bool PathService::Override(int key, const FilePath& path) {
[email protected]ff9ed9f2014-05-02 17:59:42[diff] [blame]270 // Just call the full function with true for the value of |create|, and
271 // assume that |path| may not be absolute yet.
272 return OverrideAndCreateIfNeeded(key, path, false, true);
[email protected]cb571e752012-05-09 10:50:10[diff] [blame]273}
274
[email protected]d6b3af92012-09-26 19:05:12[diff] [blame]275// static
[email protected]cb571e752012-05-09 10:50:10[diff] [blame]276bool PathService::OverrideAndCreateIfNeeded(int key,
277 const FilePath& path,
[email protected]ff9ed9f2014-05-02 17:59:42[diff] [blame]278 bool is_absolute,
[email protected]cb571e752012-05-09 10:50:10[diff] [blame]279 bool create) {
[email protected]1265917f2008-08-12 17:33:52[diff] [blame]280 PathData* path_data = GetPathData();
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]281 DCHECK(path_data);
David Dorwin15b9e1662021-11-04 19:45:05[diff] [blame]282 DCHECK_GT(key, PATH_START) << "invalid path key";
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]283
[email protected]eca6a4f2009-06-25 17:29:09[diff] [blame]284 FilePath file_path = path;
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]285
Greg Thompson53fd47592023-08-01 07:30:59[diff] [blame]286 // Create the directory if requested by the caller. Do this before resolving
287 // `file_path` to an absolute path because on POSIX, MakeAbsoluteFilePath
288 // requires that the path exists.
289 if (create && !CreateDirectory(file_path)) {
290 return false;
[email protected]cb571e752012-05-09 10:50:10[diff] [blame]291 }
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]292
[email protected]154769362013-04-12 05:17:15[diff] [blame]293 // We need to have an absolute path.
[email protected]ff9ed9f2014-05-02 17:59:42[diff] [blame]294 if (!is_absolute) {
295 file_path = MakeAbsoluteFilePath(file_path);
Peter Kasting134ef9af2024-12-28 02:30:09[diff] [blame]296 if (file_path.empty()) {
[email protected]ff9ed9f2014-05-02 17:59:42[diff] [blame]297 return false;
Peter Kasting134ef9af2024-12-28 02:30:09[diff] [blame]298 }
[email protected]ff9ed9f2014-05-02 17:59:42[diff] [blame]299 }
300 DCHECK(file_path.IsAbsolute());
[email protected]dabdb682009-10-27 23:31:36[diff] [blame]301
brettwf0dea132015-09-25 20:08:54[diff] [blame]302 AutoLock scoped_lock(path_data->lock);
[email protected]34e043b2010-09-09 23:49:04[diff] [blame]303
304 // Clear the cache now. Some of its entries could have depended
305 // on the value we are overriding, and are now out of sync with reality.
306 path_data->cache.clear();
307
Greg Thompson53fd47592023-08-01 07:30:59[diff] [blame]308 path_data->overrides[key] = std::move(file_path);
[email protected]34e043b2010-09-09 23:49:04[diff] [blame]309
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]310 return true;
311}
312
[email protected]d6b3af92012-09-26 19:05:12[diff] [blame]313// static
Mingyu Lei814f95a2025-07-03 09:05:12[diff] [blame]314bool PathService::OverrideWithoutCheckForTesting(int key,
315 const FilePath& path) {
316 PathData* path_data = GetPathData();
317 DCHECK(path_data);
318
319 AutoLock scoped_lock(path_data->lock);
320
321 // Clear the cache now. Some of its entries could have depended
322 // on the value we are overriding, and are now out of sync with reality.
323 path_data->cache.clear();
324 path_data->overrides[key] = path;
325
326 return true;
327}
328
329// static
mlcui3f0b3892020-12-10 00:11:13[diff] [blame]330bool PathService::RemoveOverrideForTests(int key) {
[email protected]d6b3af92012-09-26 19:05:12[diff] [blame]331 PathData* path_data = GetPathData();
332 DCHECK(path_data);
333
brettwf0dea132015-09-25 20:08:54[diff] [blame]334 AutoLock scoped_lock(path_data->lock);
[email protected]d6b3af92012-09-26 19:05:12[diff] [blame]335
Peter Kasting134ef9af2024-12-28 02:30:09[diff] [blame]336 if (path_data->overrides.find(key) == path_data->overrides.end()) {
[email protected]d6b3af92012-09-26 19:05:12[diff] [blame]337 return false;
Peter Kasting134ef9af2024-12-28 02:30:09[diff] [blame]338 }
[email protected]d6b3af92012-09-26 19:05:12[diff] [blame]339
340 // Clear the cache now. Some of its entries could have depended on the value
341 // we are going to remove, and are now out of sync.
342 path_data->cache.clear();
343
344 path_data->overrides.erase(key);
345
346 return true;
347}
348
349// static
David Bienvenu9d6936742023-08-21 18:30:49[diff] [blame]350bool PathService::IsOverriddenForTesting(int key) {
mlcui8a86199b2020-12-03 06:41:27[diff] [blame]351 PathData* path_data = GetPathData();
352 DCHECK(path_data);
353
354 AutoLock scoped_lock(path_data->lock);
355
356 return path_data->overrides.find(key) != path_data->overrides.end();
357}
358
359// static
Peter Kasting134ef9af2024-12-28 02:30:09[diff] [blame]360void PathService::RegisterProvider(ProviderFunc func,
361 int key_start,
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]362 int key_end) {
[email protected]1265917f2008-08-12 17:33:52[diff] [blame]363 PathData* path_data = GetPathData();
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]364 DCHECK(path_data);
[email protected]88563f682011-03-13 22:13:33[diff] [blame]365 DCHECK_GT(key_end, key_start);
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]366
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]367 Provider* p;
368
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]369 p = new Provider;
[email protected]173cb8a02008-08-20 15:47:39[diff] [blame]370 p->is_static = false;
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]371 p->func = func;
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]372#ifndef NDEBUG
373 p->key_start = key_start;
374 p->key_end = key_end;
375#endif
[email protected]d6b3af92012-09-26 19:05:12[diff] [blame]376
brettwf0dea132015-09-25 20:08:54[diff] [blame]377 AutoLock scoped_lock(path_data->lock);
[email protected]d6b3af92012-09-26 19:05:12[diff] [blame]378
379#ifndef NDEBUG
Peter Kasting134ef9af2024-12-28 02:30:09[diff] [blame]380 Provider* iter = path_data->providers;
[email protected]d6b3af92012-09-26 19:05:12[diff] [blame]381 while (iter) {
Peter Kasting134ef9af2024-12-28 02:30:09[diff] [blame]382 DCHECK(key_start >= iter->key_end || key_end <= iter->key_start)
383 << "path provider collision";
[email protected]d6b3af92012-09-26 19:05:12[diff] [blame]384 iter = iter->next;
385 }
386#endif
387
388 p->next = path_data->providers;
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]389 path_data->providers = p;
390}
[email protected]c5a726b32013-01-29 00:56:56[diff] [blame]391
392// static
393void PathService::DisableCache() {
394 PathData* path_data = GetPathData();
395 DCHECK(path_data);
396
brettwf0dea132015-09-25 20:08:54[diff] [blame]397 AutoLock scoped_lock(path_data->lock);
[email protected]c5a726b32013-01-29 00:56:56[diff] [blame]398 path_data->cache.clear();
399 path_data->cache_disabled = true;
400}
brettwf0dea132015-09-25 20:08:54[diff] [blame]401
402} // namespace base