1 // Copyright (c) 2011 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 "base/path_service.h" 6 7 #ifdef OS_WIN 8 #include <windows.h> 9 #include <shellapi.h> 10 #include <shlobj.h> 11 #endif 12 13 #include "base/file_path.h" 14 #include "base/file_util.h" 15 #include "base/hash_tables.h" 16 #include "base/lazy_instance.h" 17 #include "base/logging.h" 18 #include "base/synchronization/lock.h" 19 20 namespace base { 21 bool PathProvider(int key, FilePath* result); 22 #if defined(OS_WIN) 23 bool PathProviderWin(int key, FilePath* result); 24 #elif defined(OS_MACOSX) 25 bool PathProviderMac(int key, FilePath* result); 26 #elif defined(OS_POSIX) 27 bool PathProviderPosix(int key, FilePath* result); 28 #endif 29 } 30 31 namespace { 32 33 typedef base::hash_map<int, FilePath> PathMap; 34 35 // We keep a linked list of providers. In a debug build we ensure that no two 36 // providers claim overlapping keys. 37 struct Provider { 38 PathService::ProviderFunc func; 39 struct Provider* next; 40 #ifndef NDEBUG 41 int key_start; 42 int key_end; 43 #endif 44 bool is_static; 45 }; 46 47 static Provider base_provider = { 48 base::PathProvider, 49 NULL, 50 #ifndef NDEBUG 51 base::PATH_START, 52 base::PATH_END, 53 #endif 54 true 55 }; 56 57 #if defined(OS_WIN) 58 static Provider base_provider_win = { 59 base::PathProviderWin, 60 &base_provider, 61 #ifndef NDEBUG 62 base::PATH_WIN_START, 63 base::PATH_WIN_END, 64 #endif 65 true 66 }; 67 #endif 68 69 #if defined(OS_MACOSX) 70 static Provider base_provider_mac = { 71 base::PathProviderMac, 72 &base_provider, 73 #ifndef NDEBUG 74 base::PATH_MAC_START, 75 base::PATH_MAC_END, 76 #endif 77 true 78 }; 79 #endif 80 81 #if defined(OS_POSIX) && !defined(OS_MACOSX) 82 static Provider base_provider_posix = { 83 base::PathProviderPosix, 84 &base_provider, 85 #ifndef NDEBUG 86 0, 87 0, 88 #endif 89 true 90 }; 91 #endif 92 93 94 struct PathData { 95 base::Lock lock; 96 PathMap cache; // Cache mappings from path key to path value. 97 PathMap overrides; // Track path overrides. 98 Provider* providers; // Linked list of path service providers. 99 100 PathData() { 101 #if defined(OS_WIN) 102 providers = &base_provider_win; 103 #elif defined(OS_MACOSX) 104 providers = &base_provider_mac; 105 #elif defined(OS_POSIX) 106 providers = &base_provider_posix; 107 #endif 108 } 109 110 ~PathData() { 111 Provider* p = providers; 112 while (p) { 113 Provider* next = p->next; 114 if (!p->is_static) 115 delete p; 116 p = next; 117 } 118 } 119 }; 120 121 static base::LazyInstance<PathData> g_path_data(base::LINKER_INITIALIZED); 122 123 static PathData* GetPathData() { 124 return g_path_data.Pointer(); 125 } 126 127 } // namespace 128 129 130 // static 131 bool PathService::GetFromCache(int key, FilePath* result) { 132 PathData* path_data = GetPathData(); 133 base::AutoLock scoped_lock(path_data->lock); 134 135 // check for a cached version 136 PathMap::const_iterator it = path_data->cache.find(key); 137 if (it != path_data->cache.end()) { 138 *result = it->second; 139 return true; 140 } 141 return false; 142 } 143 144 // static 145 bool PathService::GetFromOverrides(int key, FilePath* result) { 146 PathData* path_data = GetPathData(); 147 base::AutoLock scoped_lock(path_data->lock); 148 149 // check for an overriden version. 150 PathMap::const_iterator it = path_data->overrides.find(key); 151 if (it != path_data->overrides.end()) { 152 *result = it->second; 153 return true; 154 } 155 return false; 156 } 157 158 // static 159 void PathService::AddToCache(int key, const FilePath& path) { 160 PathData* path_data = GetPathData(); 161 base::AutoLock scoped_lock(path_data->lock); 162 // Save the computed path in our cache. 163 path_data->cache[key] = path; 164 } 165 166 // TODO(brettw): this function does not handle long paths (filename > MAX_PATH) 167 // characters). This isn't supported very well by Windows right now, so it is 168 // moot, but we should keep this in mind for the future. 169 // static 170 bool PathService::Get(int key, FilePath* result) { 171 PathData* path_data = GetPathData(); 172 DCHECK(path_data); 173 DCHECK(result); 174 DCHECK_GE(key, base::DIR_CURRENT); 175 176 // special case the current directory because it can never be cached 177 if (key == base::DIR_CURRENT) 178 return file_util::GetCurrentDirectory(result); 179 180 if (GetFromCache(key, result)) 181 return true; 182 183 if (GetFromOverrides(key, result)) 184 return true; 185 186 FilePath path; 187 188 // search providers for the requested path 189 // NOTE: it should be safe to iterate here without the lock 190 // since RegisterProvider always prepends. 191 Provider* provider = path_data->providers; 192 while (provider) { 193 if (provider->func(key, &path)) 194 break; 195 DCHECK(path.empty()) << "provider should not have modified path"; 196 provider = provider->next; 197 } 198 199 if (path.empty()) 200 return false; 201 202 AddToCache(key, path); 203 204 *result = path; 205 return true; 206 } 207 208 bool PathService::Override(int key, const FilePath& path) { 209 PathData* path_data = GetPathData(); 210 DCHECK(path_data); 211 DCHECK_GT(key, base::DIR_CURRENT) << "invalid path key"; 212 213 FilePath file_path = path; 214 215 // Make sure the directory exists. We need to do this before we translate 216 // this to the absolute path because on POSIX, AbsolutePath fails if called 217 // on a non-existant path. 218 if (!file_util::PathExists(file_path) && 219 !file_util::CreateDirectory(file_path)) 220 return false; 221 222 // We need to have an absolute path, as extensions and plugins don't like 223 // relative paths, and will glady crash the browser in CHECK()s if they get a 224 // relative path. 225 if (!file_util::AbsolutePath(&file_path)) 226 return false; 227 228 base::AutoLock scoped_lock(path_data->lock); 229 230 // Clear the cache now. Some of its entries could have depended 231 // on the value we are overriding, and are now out of sync with reality. 232 path_data->cache.clear(); 233 234 path_data->cache[key] = file_path; 235 path_data->overrides[key] = file_path; 236 237 return true; 238 } 239 240 void PathService::RegisterProvider(ProviderFunc func, int key_start, 241 int key_end) { 242 PathData* path_data = GetPathData(); 243 DCHECK(path_data); 244 DCHECK_GT(key_end, key_start); 245 246 base::AutoLock scoped_lock(path_data->lock); 247 248 Provider* p; 249 250 #ifndef NDEBUG 251 p = path_data->providers; 252 while (p) { 253 DCHECK(key_start >= p->key_end || key_end <= p->key_start) << 254 "path provider collision"; 255 p = p->next; 256 } 257 #endif 258 259 p = new Provider; 260 p->is_static = false; 261 p->func = func; 262 p->next = path_data->providers; 263 #ifndef NDEBUG 264 p->key_start = key_start; 265 p->key_end = key_end; 266 #endif 267 path_data->providers = p; 268 } 269
