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/browser/download/download_path_reservation_tracker.h" 6 7 #include <map> 8 9 #include "base/bind.h" 10 #include "base/callback.h" 11 #include "base/files/file_util.h" 12 #include "base/logging.h" 13 #include "base/path_service.h" 14 #include "base/stl_util.h" 15 #include "base/strings/string_util.h" 16 #include "base/strings/stringprintf.h" 17 #include "base/third_party/icu/icu_utf.h" 18 #include "chrome/common/chrome_paths.h" 19 #include "content/public/browser/browser_thread.h" 20 #include "content/public/browser/download_item.h" 21 22 using content::BrowserThread; 23 using content::DownloadItem; 24 25 namespace { 26 27 typedef DownloadItem* ReservationKey; 28 typedef std::map<ReservationKey, base::FilePath> ReservationMap; 29 30 // The lower bound for file name truncation. If the truncation results in a name 31 // shorter than this limit, we give up automatic truncation and prompt the user. 32 static const size_t kTruncatedNameLengthLowerbound = 5; 33 34 // The length of the suffix string we append for an intermediate file name. 35 // In the file name truncation, we keep the margin to append the suffix. 36 // TODO(kinaba): remove the margin. The user should be able to set maximum 37 // possible filename. 38 static const size_t kIntermediateNameSuffixLength = sizeof(".crdownload") - 1; 39 40 // Map of download path reservations. Each reserved path is associated with a 41 // ReservationKey=DownloadItem*. This object is destroyed in |Revoke()| when 42 // there are no more reservations. 43 // 44 // It is not an error, although undesirable, to have multiple DownloadItem*s 45 // that are mapped to the same path. This can happen if a reservation is created 46 // that is supposed to overwrite an existing reservation. 47 ReservationMap* g_reservation_map = NULL; 48 49 // Observes a DownloadItem for changes to its target path and state. Updates or 50 // revokes associated download path reservations as necessary. Created, invoked 51 // and destroyed on the UI thread. 52 class DownloadItemObserver : public DownloadItem::Observer { 53 public: 54 explicit DownloadItemObserver(DownloadItem* download_item); 55 56 private: 57 virtual ~DownloadItemObserver(); 58 59 // DownloadItem::Observer 60 virtual void OnDownloadUpdated(DownloadItem* download) OVERRIDE; 61 virtual void OnDownloadDestroyed(DownloadItem* download) OVERRIDE; 62 63 DownloadItem* download_item_; 64 65 // Last known target path for the download. 66 base::FilePath last_target_path_; 67 68 DISALLOW_COPY_AND_ASSIGN(DownloadItemObserver); 69 }; 70 71 // Returns true if the given path is in use by a path reservation. 72 bool IsPathReserved(const base::FilePath& path) { 73 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE)); 74 // No reservation map => no reservations. 75 if (g_reservation_map == NULL) 76 return false; 77 // Unfortunately path normalization doesn't work reliably for non-existant 78 // files. So given a FilePath, we can't derive a normalized key that we can 79 // use for lookups. We only expect a small number of concurrent downloads at 80 // any given time, so going through all of them shouldn't be too slow. 81 for (ReservationMap::const_iterator iter = g_reservation_map->begin(); 82 iter != g_reservation_map->end(); ++iter) { 83 if (iter->second == path) 84 return true; 85 } 86 return false; 87 } 88 89 // Returns true if the given path is in use by any path reservation or the 90 // file system. Called on the FILE thread. 91 bool IsPathInUse(const base::FilePath& path) { 92 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE)); 93 // If there is a reservation, then the path is in use. 94 if (IsPathReserved(path)) 95 return true; 96 97 // If the path exists in the file system, then the path is in use. 98 if (base::PathExists(path)) 99 return true; 100 101 return false; 102 } 103 104 // Truncates path->BaseName() to make path->BaseName().value().size() <= limit. 105 // - It keeps the extension as is. Only truncates the body part. 106 // - It secures the base filename length to be more than or equals to 107 // kTruncatedNameLengthLowerbound. 108 // If it was unable to shorten the name, returns false. 109 bool TruncateFileName(base::FilePath* path, size_t limit) { 110 base::FilePath basename(path->BaseName()); 111 // It is already short enough. 112 if (basename.value().size() <= limit) 113 return true; 114 115 base::FilePath dir(path->DirName()); 116 base::FilePath::StringType ext(basename.Extension()); 117 base::FilePath::StringType name(basename.RemoveExtension().value()); 118 119 // Impossible to satisfy the limit. 120 if (limit < kTruncatedNameLengthLowerbound + ext.size()) 121 return false; 122 limit -= ext.size(); 123 124 // Encoding specific truncation logic. 125 base::FilePath::StringType truncated; 126 #if defined(OS_CHROMEOS) || defined(OS_MACOSX) 127 // UTF-8. 128 base::TruncateUTF8ToByteSize(name, limit, &truncated); 129 #elif defined(OS_WIN) 130 // UTF-16. 131 DCHECK(name.size() > limit); 132 truncated = name.substr(0, CBU16_IS_TRAIL(name[limit]) ? limit - 1 : limit); 133 #else 134 // We cannot generally assume that the file name encoding is in UTF-8 (see 135 // the comment for FilePath::AsUTF8Unsafe), hence no safe way to truncate. 136 #endif 137 138 if (truncated.size() < kTruncatedNameLengthLowerbound) 139 return false; 140 *path = dir.Append(truncated + ext); 141 return true; 142 } 143 144 // Called on the FILE thread to reserve a download path. This method: 145 // - Creates directory |default_download_path| if it doesn't exist. 146 // - Verifies that the parent directory of |suggested_path| exists and is 147 // writeable. 148 // - Truncates the suggested name if it exceeds the filesystem's limit. 149 // - Uniquifies |suggested_path| if |should_uniquify_path| is true. 150 // - Returns true if |reserved_path| has been successfully verified. 151 bool CreateReservation( 152 ReservationKey key, 153 const base::FilePath& suggested_path, 154 const base::FilePath& default_download_path, 155 bool create_directory, 156 DownloadPathReservationTracker::FilenameConflictAction conflict_action, 157 base::FilePath* reserved_path) { 158 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE)); 159 DCHECK(suggested_path.IsAbsolute()); 160 161 // Create a reservation map if one doesn't exist. It will be automatically 162 // deleted when all the reservations are revoked. 163 if (g_reservation_map == NULL) 164 g_reservation_map = new ReservationMap; 165 166 ReservationMap& reservations = *g_reservation_map; 167 DCHECK(!ContainsKey(reservations, key)); 168 169 base::FilePath target_path(suggested_path.NormalizePathSeparators()); 170 base::FilePath target_dir = target_path.DirName(); 171 base::FilePath filename = target_path.BaseName(); 172 bool is_path_writeable = true; 173 bool has_conflicts = false; 174 bool name_too_long = false; 175 176 // Create target_dir if necessary and appropriate. target_dir may be the last 177 // directory that the user selected in a FilePicker; if that directory has 178 // since been removed, do NOT automatically re-create it. Only automatically 179 // create the directory if it is the default Downloads directory or if the 180 // caller explicitly requested automatic directory creation. 181 if (!base::DirectoryExists(target_dir) && 182 (create_directory || 183 (!default_download_path.empty() && 184 (default_download_path == target_dir)))) { 185 base::CreateDirectory(target_dir); 186 } 187 188 // Check writability of the suggested path. If we can't write to it, default 189 // to the user's "My Documents" directory. We'll prompt them in this case. 190 if (!base::PathIsWritable(target_dir)) { 191 DVLOG(1) << "Unable to write to directory \"" << target_dir.value() << "\""; 192 is_path_writeable = false; 193 PathService::Get(chrome::DIR_USER_DOCUMENTS, &target_dir); 194 target_path = target_dir.Append(filename); 195 } 196 197 if (is_path_writeable) { 198 // Check the limit of file name length if it could be obtained. When the 199 // suggested name exceeds the limit, truncate or prompt the user. 200 int max_length = base::GetMaximumPathComponentLength(target_dir); 201 if (max_length != -1) { 202 int limit = max_length - kIntermediateNameSuffixLength; 203 if (limit <= 0 || !TruncateFileName(&target_path, limit)) 204 name_too_long = true; 205 } 206 207 // Uniquify the name, if it already exists. 208 if (!name_too_long && IsPathInUse(target_path)) { 209 has_conflicts = true; 210 if (conflict_action == DownloadPathReservationTracker::OVERWRITE) { 211 has_conflicts = false; 212 } 213 // If ...PROMPT, then |has_conflicts| will remain true, |verified| will be 214 // false, and CDMD will prompt. 215 if (conflict_action == DownloadPathReservationTracker::UNIQUIFY) { 216 for (int uniquifier = 1; 217 uniquifier <= DownloadPathReservationTracker::kMaxUniqueFiles; 218 ++uniquifier) { 219 // Append uniquifier. 220 std::string suffix(base::StringPrintf(" (%d)", uniquifier)); 221 base::FilePath path_to_check(target_path); 222 // If the name length limit is available (max_length != -1), and the 223 // the current name exceeds the limit, truncate. 224 if (max_length != -1) { 225 int limit = 226 max_length - kIntermediateNameSuffixLength - suffix.size(); 227 // If truncation failed, give up uniquification. 228 if (limit <= 0 || !TruncateFileName(&path_to_check, limit)) 229 break; 230 } 231 path_to_check = path_to_check.InsertBeforeExtensionASCII(suffix); 232 233 if (!IsPathInUse(path_to_check)) { 234 target_path = path_to_check; 235 has_conflicts = false; 236 break; 237 } 238 } 239 } 240 } 241 } 242 243 reservations[key] = target_path; 244 bool verified = (is_path_writeable && !has_conflicts && !name_too_long); 245 *reserved_path = target_path; 246 return verified; 247 } 248 249 // Called on the FILE thread to update the path of the reservation associated 250 // with |key| to |new_path|. 251 void UpdateReservation(ReservationKey key, const base::FilePath& new_path) { 252 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE)); 253 DCHECK(g_reservation_map != NULL); 254 ReservationMap::iterator iter = g_reservation_map->find(key); 255 if (iter != g_reservation_map->end()) { 256 iter->second = new_path; 257 } else { 258 // This would happen if an UpdateReservation() notification was scheduled on 259 // the FILE thread before ReserveInternal(), or after a Revoke() 260 // call. Neither should happen. 261 NOTREACHED(); 262 } 263 } 264 265 // Called on the FILE thread to remove the path reservation associated with 266 // |key|. 267 void RevokeReservation(ReservationKey key) { 268 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE)); 269 DCHECK(g_reservation_map != NULL); 270 DCHECK(ContainsKey(*g_reservation_map, key)); 271 g_reservation_map->erase(key); 272 if (g_reservation_map->size() == 0) { 273 // No more reservations. Delete map. 274 delete g_reservation_map; 275 g_reservation_map = NULL; 276 } 277 } 278 279 void RunGetReservedPathCallback( 280 const DownloadPathReservationTracker::ReservedPathCallback& callback, 281 const base::FilePath* reserved_path, 282 bool verified) { 283 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 284 callback.Run(*reserved_path, verified); 285 } 286 287 DownloadItemObserver::DownloadItemObserver(DownloadItem* download_item) 288 : download_item_(download_item), 289 last_target_path_(download_item->GetTargetFilePath()) { 290 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 291 download_item_->AddObserver(this); 292 } 293 294 DownloadItemObserver::~DownloadItemObserver() { 295 download_item_->RemoveObserver(this); 296 } 297 298 void DownloadItemObserver::OnDownloadUpdated(DownloadItem* download) { 299 switch (download->GetState()) { 300 case DownloadItem::IN_PROGRESS: { 301 // Update the reservation. 302 base::FilePath new_target_path = download->GetTargetFilePath(); 303 if (new_target_path != last_target_path_) { 304 BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, base::Bind( 305 &UpdateReservation, download, new_target_path)); 306 last_target_path_ = new_target_path; 307 } 308 break; 309 } 310 311 case DownloadItem::COMPLETE: 312 // If the download is complete, then it has already been renamed to the 313 // final name. The existence of the file on disk is sufficient to prevent 314 // conflicts from now on. 315 316 case DownloadItem::CANCELLED: 317 // We no longer need the reservation if the download is being removed. 318 319 case DownloadItem::INTERRUPTED: 320 // The download filename will need to be re-generated when the download is 321 // restarted. Holding on to the reservation now would prevent the name 322 // from being used for a subsequent retry attempt. 323 324 BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, base::Bind( 325 &RevokeReservation, download)); 326 delete this; 327 break; 328 329 case DownloadItem::MAX_DOWNLOAD_STATE: 330 // Compiler appeasement. 331 NOTREACHED(); 332 } 333 } 334 335 void DownloadItemObserver::OnDownloadDestroyed(DownloadItem* download) { 336 // Items should be COMPLETE/INTERRUPTED/CANCELLED before being destroyed. 337 NOTREACHED(); 338 BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, base::Bind( 339 &RevokeReservation, download)); 340 delete this; 341 } 342 343 } // namespace 344 345 // static 346 void DownloadPathReservationTracker::GetReservedPath( 347 DownloadItem* download_item, 348 const base::FilePath& target_path, 349 const base::FilePath& default_path, 350 bool create_directory, 351 FilenameConflictAction conflict_action, 352 const ReservedPathCallback& callback) { 353 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 354 // Attach an observer to the download item so that we know when the target 355 // path changes and/or the download is no longer active. 356 new DownloadItemObserver(download_item); 357 // DownloadItemObserver deletes itself. 358 359 base::FilePath* reserved_path = new base::FilePath; 360 BrowserThread::PostTaskAndReplyWithResult( 361 BrowserThread::FILE, 362 FROM_HERE, 363 base::Bind(&CreateReservation, 364 download_item, 365 target_path, 366 default_path, 367 create_directory, 368 conflict_action, 369 reserved_path), 370 base::Bind(&RunGetReservedPathCallback, 371 callback, 372 base::Owned(reserved_path))); 373 } 374 375 // static 376 bool DownloadPathReservationTracker::IsPathInUseForTesting( 377 const base::FilePath& path) { 378 return IsPathInUse(path); 379 } 380
