| OLD | NEW |
|---|
| (Empty) |
| 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 "webkit/browser/fileapi/obfuscated_file_util.h" | |
| 6 | |
| 7 #include <queue> | |
| 8 #include <string> | |
| 9 #include <vector> | |
| 10 | |
| 11 #include "base/file_util.h" | |
| 12 #include "base/format_macros.h" | |
| 13 #include "base/logging.h" | |
| 14 #include "base/message_loop/message_loop.h" | |
| 15 #include "base/metrics/histogram.h" | |
| 16 #include "base/stl_util.h" | |
| 17 #include "base/strings/string_number_conversions.h" | |
| 18 #include "base/strings/stringprintf.h" | |
| 19 #include "base/strings/sys_string_conversions.h" | |
| 20 #include "base/strings/utf_string_conversions.h" | |
| 21 #include "base/time/time.h" | |
| 22 #include "url/gurl.h" | |
| 23 #include "webkit/browser/fileapi/file_observers.h" | |
| 24 #include "webkit/browser/fileapi/file_system_context.h" | |
| 25 #include "webkit/browser/fileapi/file_system_operation_context.h" | |
| 26 #include "webkit/browser/fileapi/file_system_url.h" | |
| 27 #include "webkit/browser/fileapi/native_file_util.h" | |
| 28 #include "webkit/browser/fileapi/sandbox_file_system_backend.h" | |
| 29 #include "webkit/browser/fileapi/sandbox_isolated_origin_database.h" | |
| 30 #include "webkit/browser/fileapi/sandbox_origin_database.h" | |
| 31 #include "webkit/browser/fileapi/sandbox_prioritized_origin_database.h" | |
| 32 #include "webkit/browser/fileapi/timed_task_helper.h" | |
| 33 #include "webkit/browser/quota/quota_manager.h" | |
| 34 #include "webkit/common/database/database_identifier.h" | |
| 35 #include "webkit/common/fileapi/file_system_util.h" | |
| 36 | |
| 37 // Example of various paths: | |
| 38 // void ObfuscatedFileUtil::DoSomething(const FileSystemURL& url) { | |
| 39 // base::FilePath virtual_path = url.path(); | |
| 40 // base::FilePath local_path = GetLocalFilePath(url); | |
| 41 // | |
| 42 // NativeFileUtil::DoSomething(local_path); | |
| 43 // file_util::DoAnother(local_path); | |
| 44 // } | |
| 45 | |
| 46 namespace fileapi { | |
| 47 | |
| 48 namespace { | |
| 49 | |
| 50 typedef SandboxDirectoryDatabase::FileId FileId; | |
| 51 typedef SandboxDirectoryDatabase::FileInfo FileInfo; | |
| 52 | |
| 53 void InitFileInfo( | |
| 54 SandboxDirectoryDatabase::FileInfo* file_info, | |
| 55 SandboxDirectoryDatabase::FileId parent_id, | |
| 56 const base::FilePath::StringType& file_name) { | |
| 57 DCHECK(file_info); | |
| 58 file_info->parent_id = parent_id; | |
| 59 file_info->name = file_name; | |
| 60 } | |
| 61 | |
| 62 // Costs computed as per crbug.com/86114, based on the LevelDB implementation of | |
| 63 // path storage under Linux. It's not clear if that will differ on Windows, on | |
| 64 // which base::FilePath uses wide chars [since they're converted to UTF-8 for | |
| 65 // storage anyway], but as long as the cost is high enough that one can't cheat | |
| 66 // on quota by storing data in paths, it doesn't need to be all that accurate. | |
| 67 const int64 kPathCreationQuotaCost = 146; // Bytes per inode, basically. | |
| 68 const int64 kPathByteQuotaCost = 2; // Bytes per byte of path length in UTF-8. | |
| 69 | |
| 70 int64 UsageForPath(size_t length) { | |
| 71 return kPathCreationQuotaCost + | |
| 72 static_cast<int64>(length) * kPathByteQuotaCost; | |
| 73 } | |
| 74 | |
| 75 bool AllocateQuota(FileSystemOperationContext* context, int64 growth) { | |
| 76 if (context->allowed_bytes_growth() == quota::QuotaManager::kNoLimit) | |
| 77 return true; | |
| 78 | |
| 79 int64 new_quota = context->allowed_bytes_growth() - growth; | |
| 80 if (growth > 0 && new_quota < 0) | |
| 81 return false; | |
| 82 context->set_allowed_bytes_growth(new_quota); | |
| 83 return true; | |
| 84 } | |
| 85 | |
| 86 void UpdateUsage( | |
| 87 FileSystemOperationContext* context, | |
| 88 const FileSystemURL& url, | |
| 89 int64 growth) { | |
| 90 context->update_observers()->Notify( | |
| 91 &FileUpdateObserver::OnUpdate, MakeTuple(url, growth)); | |
| 92 } | |
| 93 | |
| 94 void TouchDirectory(SandboxDirectoryDatabase* db, FileId dir_id) { | |
| 95 DCHECK(db); | |
| 96 if (!db->UpdateModificationTime(dir_id, base::Time::Now())) | |
| 97 NOTREACHED(); | |
| 98 } | |
| 99 | |
| 100 enum IsolatedOriginStatus { | |
| 101 kIsolatedOriginMatch, | |
| 102 kIsolatedOriginDontMatch, | |
| 103 kIsolatedOriginStatusMax, | |
| 104 }; | |
| 105 | |
| 106 } // namespace | |
| 107 | |
| 108 class ObfuscatedFileEnumerator | |
| 109 : public FileSystemFileUtil::AbstractFileEnumerator { | |
| 110 public: | |
| 111 ObfuscatedFileEnumerator( | |
| 112 SandboxDirectoryDatabase* db, | |
| 113 FileSystemOperationContext* context, | |
| 114 ObfuscatedFileUtil* obfuscated_file_util, | |
| 115 const FileSystemURL& root_url, | |
| 116 bool recursive) | |
| 117 : db_(db), | |
| 118 context_(context), | |
| 119 obfuscated_file_util_(obfuscated_file_util), | |
| 120 root_url_(root_url), | |
| 121 recursive_(recursive), | |
| 122 current_file_id_(0) { | |
| 123 base::FilePath root_virtual_path = root_url.path(); | |
| 124 FileId file_id; | |
| 125 | |
| 126 if (!db_->GetFileWithPath(root_virtual_path, &file_id)) | |
| 127 return; | |
| 128 | |
| 129 FileRecord record = { file_id, root_virtual_path }; | |
| 130 recurse_queue_.push(record); | |
| 131 } | |
| 132 | |
| 133 virtual ~ObfuscatedFileEnumerator() {} | |
| 134 | |
| 135 virtual base::FilePath Next() OVERRIDE { | |
| 136 ProcessRecurseQueue(); | |
| 137 if (display_stack_.empty()) | |
| 138 return base::FilePath(); | |
| 139 | |
| 140 current_file_id_ = display_stack_.back(); | |
| 141 display_stack_.pop_back(); | |
| 142 | |
| 143 FileInfo file_info; | |
| 144 base::FilePath platform_file_path; | |
| 145 base::File::Error error = | |
| 146 obfuscated_file_util_->GetFileInfoInternal( | |
| 147 db_, context_, root_url_, current_file_id_, | |
| 148 &file_info, ¤t_platform_file_info_, &platform_file_path); | |
| 149 if (error != base::File::FILE_OK) | |
| 150 return Next(); | |
| 151 | |
| 152 base::FilePath virtual_path = | |
| 153 current_parent_virtual_path_.Append(file_info.name); | |
| 154 if (recursive_ && file_info.is_directory()) { | |
| 155 FileRecord record = { current_file_id_, virtual_path }; | |
| 156 recurse_queue_.push(record); | |
| 157 } | |
| 158 return virtual_path; | |
| 159 } | |
| 160 | |
| 161 virtual int64 Size() OVERRIDE { | |
| 162 return current_platform_file_info_.size; | |
| 163 } | |
| 164 | |
| 165 virtual base::Time LastModifiedTime() OVERRIDE { | |
| 166 return current_platform_file_info_.last_modified; | |
| 167 } | |
| 168 | |
| 169 virtual bool IsDirectory() OVERRIDE { | |
| 170 return current_platform_file_info_.is_directory; | |
| 171 } | |
| 172 | |
| 173 private: | |
| 174 typedef SandboxDirectoryDatabase::FileId FileId; | |
| 175 typedef SandboxDirectoryDatabase::FileInfo FileInfo; | |
| 176 | |
| 177 struct FileRecord { | |
| 178 FileId file_id; | |
| 179 base::FilePath virtual_path; | |
| 180 }; | |
| 181 | |
| 182 void ProcessRecurseQueue() { | |
| 183 while (display_stack_.empty() && !recurse_queue_.empty()) { | |
| 184 FileRecord entry = recurse_queue_.front(); | |
| 185 recurse_queue_.pop(); | |
| 186 if (!db_->ListChildren(entry.file_id, &display_stack_)) { | |
| 187 display_stack_.clear(); | |
| 188 return; | |
| 189 } | |
| 190 current_parent_virtual_path_ = entry.virtual_path; | |
| 191 } | |
| 192 } | |
| 193 | |
| 194 SandboxDirectoryDatabase* db_; | |
| 195 FileSystemOperationContext* context_; | |
| 196 ObfuscatedFileUtil* obfuscated_file_util_; | |
| 197 FileSystemURL root_url_; | |
| 198 bool recursive_; | |
| 199 | |
| 200 std::queue<FileRecord> recurse_queue_; | |
| 201 std::vector<FileId> display_stack_; | |
| 202 base::FilePath current_parent_virtual_path_; | |
| 203 | |
| 204 FileId current_file_id_; | |
| 205 base::File::Info current_platform_file_info_; | |
| 206 }; | |
| 207 | |
| 208 class ObfuscatedOriginEnumerator | |
| 209 : public ObfuscatedFileUtil::AbstractOriginEnumerator { | |
| 210 public: | |
| 211 typedef SandboxOriginDatabase::OriginRecord OriginRecord; | |
| 212 ObfuscatedOriginEnumerator( | |
| 213 SandboxOriginDatabaseInterface* origin_database, | |
| 214 const base::FilePath& base_file_path) | |
| 215 : base_file_path_(base_file_path) { | |
| 216 if (origin_database) | |
| 217 origin_database->ListAllOrigins(&origins_); | |
| 218 } | |
| 219 | |
| 220 virtual ~ObfuscatedOriginEnumerator() {} | |
| 221 | |
| 222 // Returns the next origin. Returns empty if there are no more origins. | |
| 223 virtual GURL Next() OVERRIDE { | |
| 224 OriginRecord record; | |
| 225 if (!origins_.empty()) { | |
| 226 record = origins_.back(); | |
| 227 origins_.pop_back(); | |
| 228 } | |
| 229 current_ = record; | |
| 230 return webkit_database::GetOriginFromIdentifier(record.origin); | |
| 231 } | |
| 232 | |
| 233 // Returns the current origin's information. | |
| 234 virtual bool HasTypeDirectory(const std::string& type_string) const OVERRIDE { | |
| 235 if (current_.path.empty()) | |
| 236 return false; | |
| 237 if (type_string.empty()) { | |
| 238 NOTREACHED(); | |
| 239 return false; | |
| 240 } | |
| 241 base::FilePath path = | |
| 242 base_file_path_.Append(current_.path).AppendASCII(type_string); | |
| 243 return base::DirectoryExists(path); | |
| 244 } | |
| 245 | |
| 246 private: | |
| 247 std::vector<OriginRecord> origins_; | |
| 248 OriginRecord current_; | |
| 249 base::FilePath base_file_path_; | |
| 250 }; | |
| 251 | |
| 252 ObfuscatedFileUtil::ObfuscatedFileUtil( | |
| 253 quota::SpecialStoragePolicy* special_storage_policy, | |
| 254 const base::FilePath& file_system_directory, | |
| 255 leveldb::Env* env_override, | |
| 256 base::SequencedTaskRunner* file_task_runner, | |
| 257 const GetTypeStringForURLCallback& get_type_string_for_url, | |
| 258 const std::set<std::string>& known_type_strings, | |
| 259 SandboxFileSystemBackendDelegate* sandbox_delegate) | |
| 260 : special_storage_policy_(special_storage_policy), | |
| 261 file_system_directory_(file_system_directory), | |
| 262 env_override_(env_override), | |
| 263 db_flush_delay_seconds_(10 * 60), // 10 mins. | |
| 264 file_task_runner_(file_task_runner), | |
| 265 get_type_string_for_url_(get_type_string_for_url), | |
| 266 known_type_strings_(known_type_strings), | |
| 267 sandbox_delegate_(sandbox_delegate) { | |
| 268 } | |
| 269 | |
| 270 ObfuscatedFileUtil::~ObfuscatedFileUtil() { | |
| 271 DropDatabases(); | |
| 272 } | |
| 273 | |
| 274 base::File ObfuscatedFileUtil::CreateOrOpen( | |
| 275 FileSystemOperationContext* context, | |
| 276 const FileSystemURL& url, int file_flags) { | |
| 277 base::File file = CreateOrOpenInternal(context, url, file_flags); | |
| 278 if (file.IsValid() && file_flags & base::File::FLAG_WRITE && | |
| 279 context->quota_limit_type() == quota::kQuotaLimitTypeUnlimited && | |
| 280 sandbox_delegate_) { | |
| 281 sandbox_delegate_->StickyInvalidateUsageCache(url.origin(), url.type()); | |
| 282 } | |
| 283 return file.Pass(); | |
| 284 } | |
| 285 | |
| 286 base::File::Error ObfuscatedFileUtil::EnsureFileExists( | |
| 287 FileSystemOperationContext* context, | |
| 288 const FileSystemURL& url, | |
| 289 bool* created) { | |
| 290 SandboxDirectoryDatabase* db = GetDirectoryDatabase(url, true); | |
| 291 if (!db) | |
| 292 return base::File::FILE_ERROR_FAILED; | |
| 293 | |
| 294 FileId file_id; | |
| 295 if (db->GetFileWithPath(url.path(), &file_id)) { | |
| 296 FileInfo file_info; | |
| 297 if (!db->GetFileInfo(file_id, &file_info)) { | |
| 298 NOTREACHED(); | |
| 299 return base::File::FILE_ERROR_FAILED; | |
| 300 } | |
| 301 if (file_info.is_directory()) | |
| 302 return base::File::FILE_ERROR_NOT_A_FILE; | |
| 303 if (created) | |
| 304 *created = false; | |
| 305 return base::File::FILE_OK; | |
| 306 } | |
| 307 FileId parent_id; | |
| 308 if (!db->GetFileWithPath(VirtualPath::DirName(url.path()), &parent_id)) | |
| 309 return base::File::FILE_ERROR_NOT_FOUND; | |
| 310 | |
| 311 FileInfo file_info; | |
| 312 InitFileInfo(&file_info, parent_id, | |
| 313 VirtualPath::BaseName(url.path()).value()); | |
| 314 | |
| 315 int64 growth = UsageForPath(file_info.name.size()); | |
| 316 if (!AllocateQuota(context, growth)) | |
| 317 return base::File::FILE_ERROR_NO_SPACE; | |
| 318 base::File::Error error = CreateFile(context, base::FilePath(), url, | |
| 319 &file_info); | |
| 320 if (created && base::File::FILE_OK == error) { | |
| 321 *created = true; | |
| 322 UpdateUsage(context, url, growth); | |
| 323 context->change_observers()->Notify( | |
| 324 &FileChangeObserver::OnCreateFile, MakeTuple(url)); | |
| 325 } | |
| 326 return error; | |
| 327 } | |
| 328 | |
| 329 base::File::Error ObfuscatedFileUtil::CreateDirectory( | |
| 330 FileSystemOperationContext* context, | |
| 331 const FileSystemURL& url, | |
| 332 bool exclusive, | |
| 333 bool recursive) { | |
| 334 SandboxDirectoryDatabase* db = GetDirectoryDatabase(url, true); | |
| 335 if (!db) | |
| 336 return base::File::FILE_ERROR_FAILED; | |
| 337 | |
| 338 FileId file_id; | |
| 339 if (db->GetFileWithPath(url.path(), &file_id)) { | |
| 340 FileInfo file_info; | |
| 341 if (exclusive) | |
| 342 return base::File::FILE_ERROR_EXISTS; | |
| 343 if (!db->GetFileInfo(file_id, &file_info)) { | |
| 344 NOTREACHED(); | |
| 345 return base::File::FILE_ERROR_FAILED; | |
| 346 } | |
| 347 if (!file_info.is_directory()) | |
| 348 return base::File::FILE_ERROR_NOT_A_DIRECTORY; | |
| 349 return base::File::FILE_OK; | |
| 350 } | |
| 351 | |
| 352 std::vector<base::FilePath::StringType> components; | |
| 353 VirtualPath::GetComponents(url.path(), &components); | |
| 354 FileId parent_id = 0; | |
| 355 size_t index; | |
| 356 for (index = 0; index < components.size(); ++index) { | |
| 357 base::FilePath::StringType name = components[index]; | |
| 358 if (name == FILE_PATH_LITERAL("/")) | |
| 359 continue; | |
| 360 if (!db->GetChildWithName(parent_id, name, &parent_id)) | |
| 361 break; | |
| 362 } | |
| 363 if (!db->IsDirectory(parent_id)) | |
| 364 return base::File::FILE_ERROR_NOT_A_DIRECTORY; | |
| 365 if (!recursive && components.size() - index > 1) | |
| 366 return base::File::FILE_ERROR_NOT_FOUND; | |
| 367 bool first = true; | |
| 368 for (; index < components.size(); ++index) { | |
| 369 FileInfo file_info; | |
| 370 file_info.name = components[index]; | |
| 371 if (file_info.name == FILE_PATH_LITERAL("/")) | |
| 372 continue; | |
| 373 file_info.modification_time = base::Time::Now(); | |
| 374 file_info.parent_id = parent_id; | |
| 375 int64 growth = UsageForPath(file_info.name.size()); | |
| 376 if (!AllocateQuota(context, growth)) | |
| 377 return base::File::FILE_ERROR_NO_SPACE; | |
| 378 base::File::Error error = db->AddFileInfo(file_info, &parent_id); | |
| 379 if (error != base::File::FILE_OK) | |
| 380 return error; | |
| 381 UpdateUsage(context, url, growth); | |
| 382 context->change_observers()->Notify( | |
| 383 &FileChangeObserver::OnCreateDirectory, MakeTuple(url)); | |
| 384 if (first) { | |
| 385 first = false; | |
| 386 TouchDirectory(db, file_info.parent_id); | |
| 387 } | |
| 388 } | |
| 389 return base::File::FILE_OK; | |
| 390 } | |
| 391 | |
| 392 base::File::Error ObfuscatedFileUtil::GetFileInfo( | |
| 393 FileSystemOperationContext* context, | |
| 394 const FileSystemURL& url, | |
| 395 base::File::Info* file_info, | |
| 396 base::FilePath* platform_file_path) { | |
| 397 SandboxDirectoryDatabase* db = GetDirectoryDatabase(url, false); | |
| 398 if (!db) | |
| 399 return base::File::FILE_ERROR_NOT_FOUND; | |
| 400 FileId file_id; | |
| 401 if (!db->GetFileWithPath(url.path(), &file_id)) | |
| 402 return base::File::FILE_ERROR_NOT_FOUND; | |
| 403 FileInfo local_info; | |
| 404 return GetFileInfoInternal(db, context, url, | |
| 405 file_id, &local_info, | |
| 406 file_info, platform_file_path); | |
| 407 } | |
| 408 | |
| 409 scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator> | |
| 410 ObfuscatedFileUtil::CreateFileEnumerator( | |
| 411 FileSystemOperationContext* context, | |
| 412 const FileSystemURL& root_url) { | |
| 413 return CreateFileEnumerator(context, root_url, false /* recursive */); | |
| 414 } | |
| 415 | |
| 416 base::File::Error ObfuscatedFileUtil::GetLocalFilePath( | |
| 417 FileSystemOperationContext* context, | |
| 418 const FileSystemURL& url, | |
| 419 base::FilePath* local_path) { | |
| 420 SandboxDirectoryDatabase* db = GetDirectoryDatabase(url, false); | |
| 421 if (!db) | |
| 422 return base::File::FILE_ERROR_NOT_FOUND; | |
| 423 FileId file_id; | |
| 424 if (!db->GetFileWithPath(url.path(), &file_id)) | |
| 425 return base::File::FILE_ERROR_NOT_FOUND; | |
| 426 FileInfo file_info; | |
| 427 if (!db->GetFileInfo(file_id, &file_info) || file_info.is_directory()) { | |
| 428 NOTREACHED(); | |
| 429 // Directories have no local file path. | |
| 430 return base::File::FILE_ERROR_NOT_FOUND; | |
| 431 } | |
| 432 *local_path = DataPathToLocalPath(url, file_info.data_path); | |
| 433 | |
| 434 if (local_path->empty()) | |
| 435 return base::File::FILE_ERROR_NOT_FOUND; | |
| 436 return base::File::FILE_OK; | |
| 437 } | |
| 438 | |
| 439 base::File::Error ObfuscatedFileUtil::Touch( | |
| 440 FileSystemOperationContext* context, | |
| 441 const FileSystemURL& url, | |
| 442 const base::Time& last_access_time, | |
| 443 const base::Time& last_modified_time) { | |
| 444 SandboxDirectoryDatabase* db = GetDirectoryDatabase(url, false); | |
| 445 if (!db) | |
| 446 return base::File::FILE_ERROR_NOT_FOUND; | |
| 447 FileId file_id; | |
| 448 if (!db->GetFileWithPath(url.path(), &file_id)) | |
| 449 return base::File::FILE_ERROR_NOT_FOUND; | |
| 450 | |
| 451 FileInfo file_info; | |
| 452 if (!db->GetFileInfo(file_id, &file_info)) { | |
| 453 NOTREACHED(); | |
| 454 return base::File::FILE_ERROR_FAILED; | |
| 455 } | |
| 456 if (file_info.is_directory()) { | |
| 457 if (!db->UpdateModificationTime(file_id, last_modified_time)) | |
| 458 return base::File::FILE_ERROR_FAILED; | |
| 459 return base::File::FILE_OK; | |
| 460 } | |
| 461 return NativeFileUtil::Touch( | |
| 462 DataPathToLocalPath(url, file_info.data_path), | |
| 463 last_access_time, last_modified_time); | |
| 464 } | |
| 465 | |
| 466 base::File::Error ObfuscatedFileUtil::Truncate( | |
| 467 FileSystemOperationContext* context, | |
| 468 const FileSystemURL& url, | |
| 469 int64 length) { | |
| 470 base::File::Info file_info; | |
| 471 base::FilePath local_path; | |
| 472 base::File::Error error = | |
| 473 GetFileInfo(context, url, &file_info, &local_path); | |
| 474 if (error != base::File::FILE_OK) | |
| 475 return error; | |
| 476 | |
| 477 int64 growth = length - file_info.size; | |
| 478 if (!AllocateQuota(context, growth)) | |
| 479 return base::File::FILE_ERROR_NO_SPACE; | |
| 480 error = NativeFileUtil::Truncate(local_path, length); | |
| 481 if (error == base::File::FILE_OK) { | |
| 482 UpdateUsage(context, url, growth); | |
| 483 context->change_observers()->Notify( | |
| 484 &FileChangeObserver::OnModifyFile, MakeTuple(url)); | |
| 485 } | |
| 486 return error; | |
| 487 } | |
| 488 | |
| 489 base::File::Error ObfuscatedFileUtil::CopyOrMoveFile( | |
| 490 FileSystemOperationContext* context, | |
| 491 const FileSystemURL& src_url, | |
| 492 const FileSystemURL& dest_url, | |
| 493 CopyOrMoveOption option, | |
| 494 bool copy) { | |
| 495 // Cross-filesystem copies and moves should be handled via CopyInForeignFile. | |
| 496 DCHECK(src_url.origin() == dest_url.origin()); | |
| 497 DCHECK(src_url.type() == dest_url.type()); | |
| 498 | |
| 499 SandboxDirectoryDatabase* db = GetDirectoryDatabase(src_url, true); | |
| 500 if (!db) | |
| 501 return base::File::FILE_ERROR_FAILED; | |
| 502 | |
| 503 FileId src_file_id; | |
| 504 if (!db->GetFileWithPath(src_url.path(), &src_file_id)) | |
| 505 return base::File::FILE_ERROR_NOT_FOUND; | |
| 506 | |
| 507 FileId dest_file_id; | |
| 508 bool overwrite = db->GetFileWithPath(dest_url.path(), | |
| 509 &dest_file_id); | |
| 510 | |
| 511 FileInfo src_file_info; | |
| 512 base::File::Info src_platform_file_info; | |
| 513 base::FilePath src_local_path; | |
| 514 base::File::Error error = GetFileInfoInternal( | |
| 515 db, context, src_url, src_file_id, | |
| 516 &src_file_info, &src_platform_file_info, &src_local_path); | |
| 517 if (error != base::File::FILE_OK) | |
| 518 return error; | |
| 519 if (src_file_info.is_directory()) | |
| 520 return base::File::FILE_ERROR_NOT_A_FILE; | |
| 521 | |
| 522 FileInfo dest_file_info; | |
| 523 base::File::Info dest_platform_file_info; // overwrite case only | |
| 524 base::FilePath dest_local_path; // overwrite case only | |
| 525 if (overwrite) { | |
| 526 base::File::Error error = GetFileInfoInternal( | |
| 527 db, context, dest_url, dest_file_id, | |
| 528 &dest_file_info, &dest_platform_file_info, &dest_local_path); | |
| 529 if (error == base::File::FILE_ERROR_NOT_FOUND) | |
| 530 overwrite = false; // fallback to non-overwrite case | |
| 531 else if (error != base::File::FILE_OK) | |
| 532 return error; | |
| 533 else if (dest_file_info.is_directory()) | |
| 534 return base::File::FILE_ERROR_INVALID_OPERATION; | |
| 535 } | |
| 536 if (!overwrite) { | |
| 537 FileId dest_parent_id; | |
| 538 if (!db->GetFileWithPath(VirtualPath::DirName(dest_url.path()), | |
| 539 &dest_parent_id)) { | |
| 540 return base::File::FILE_ERROR_NOT_FOUND; | |
| 541 } | |
| 542 | |
| 543 dest_file_info = src_file_info; | |
| 544 dest_file_info.parent_id = dest_parent_id; | |
| 545 dest_file_info.name = | |
| 546 VirtualPath::BaseName(dest_url.path()).value(); | |
| 547 } | |
| 548 | |
| 549 int64 growth = 0; | |
| 550 if (copy) | |
| 551 growth += src_platform_file_info.size; | |
| 552 else | |
| 553 growth -= UsageForPath(src_file_info.name.size()); | |
| 554 if (overwrite) | |
| 555 growth -= dest_platform_file_info.size; | |
| 556 else | |
| 557 growth += UsageForPath(dest_file_info.name.size()); | |
| 558 if (!AllocateQuota(context, growth)) | |
| 559 return base::File::FILE_ERROR_NO_SPACE; | |
| 560 | |
| 561 /* | |
| 562 * Copy-with-overwrite | |
| 563 * Just overwrite data file | |
| 564 * Copy-without-overwrite | |
| 565 * Copy backing file | |
| 566 * Create new metadata pointing to new backing file. | |
| 567 * Move-with-overwrite | |
| 568 * transaction: | |
| 569 * Remove source entry. | |
| 570 * Point target entry to source entry's backing file. | |
| 571 * Delete target entry's old backing file | |
| 572 * Move-without-overwrite | |
| 573 * Just update metadata | |
| 574 */ | |
| 575 error = base::File::FILE_ERROR_FAILED; | |
| 576 if (copy) { | |
| 577 if (overwrite) { | |
| 578 error = NativeFileUtil::CopyOrMoveFile( | |
| 579 src_local_path, | |
| 580 dest_local_path, | |
| 581 option, | |
| 582 fileapi::NativeFileUtil::CopyOrMoveModeForDestination( | |
| 583 dest_url, true /* copy */)); | |
| 584 } else { // non-overwrite | |
| 585 error = CreateFile(context, src_local_path, dest_url, &dest_file_info); | |
| 586 } | |
| 587 } else { | |
| 588 if (overwrite) { | |
| 589 if (db->OverwritingMoveFile(src_file_id, dest_file_id)) { | |
| 590 if (base::File::FILE_OK != | |
| 591 NativeFileUtil::DeleteFile(dest_local_path)) | |
| 592 LOG(WARNING) << "Leaked a backing file."; | |
| 593 error = base::File::FILE_OK; | |
| 594 } else { | |
| 595 error = base::File::FILE_ERROR_FAILED; | |
| 596 } | |
| 597 } else { // non-overwrite | |
| 598 if (db->UpdateFileInfo(src_file_id, dest_file_info)) | |
| 599 error = base::File::FILE_OK; | |
| 600 else | |
| 601 error = base::File::FILE_ERROR_FAILED; | |
| 602 } | |
| 603 } | |
| 604 | |
| 605 if (error != base::File::FILE_OK) | |
| 606 return error; | |
| 607 | |
| 608 if (overwrite) { | |
| 609 context->change_observers()->Notify( | |
| 610 &FileChangeObserver::OnModifyFile, | |
| 611 MakeTuple(dest_url)); | |
| 612 } else { | |
| 613 context->change_observers()->Notify( | |
| 614 &FileChangeObserver::OnCreateFileFrom, | |
| 615 MakeTuple(dest_url, src_url)); | |
| 616 } | |
| 617 | |
| 618 if (!copy) { | |
| 619 context->change_observers()->Notify( | |
| 620 &FileChangeObserver::OnRemoveFile, MakeTuple(src_url)); | |
| 621 TouchDirectory(db, src_file_info.parent_id); | |
| 622 } | |
| 623 | |
| 624 TouchDirectory(db, dest_file_info.parent_id); | |
| 625 | |
| 626 UpdateUsage(context, dest_url, growth); | |
| 627 return error; | |
| 628 } | |
| 629 | |
| 630 base::File::Error ObfuscatedFileUtil::CopyInForeignFile( | |
| 631 FileSystemOperationContext* context, | |
| 632 const base::FilePath& src_file_path, | |
| 633 const FileSystemURL& dest_url) { | |
| 634 SandboxDirectoryDatabase* db = GetDirectoryDatabase(dest_url, true); | |
| 635 if (!db) | |
| 636 return base::File::FILE_ERROR_FAILED; | |
| 637 | |
| 638 base::File::Info src_platform_file_info; | |
| 639 if (!base::GetFileInfo(src_file_path, &src_platform_file_info)) | |
| 640 return base::File::FILE_ERROR_NOT_FOUND; | |
| 641 | |
| 642 FileId dest_file_id; | |
| 643 bool overwrite = db->GetFileWithPath(dest_url.path(), | |
| 644 &dest_file_id); | |
| 645 | |
| 646 FileInfo dest_file_info; | |
| 647 base::File::Info dest_platform_file_info; // overwrite case only | |
| 648 if (overwrite) { | |
| 649 base::FilePath dest_local_path; | |
| 650 base::File::Error error = GetFileInfoInternal( | |
| 651 db, context, dest_url, dest_file_id, | |
| 652 &dest_file_info, &dest_platform_file_info, &dest_local_path); | |
| 653 if (error == base::File::FILE_ERROR_NOT_FOUND) | |
| 654 overwrite = false; // fallback to non-overwrite case | |
| 655 else if (error != base::File::FILE_OK) | |
| 656 return error; | |
| 657 else if (dest_file_info.is_directory()) | |
| 658 return base::File::FILE_ERROR_INVALID_OPERATION; | |
| 659 } | |
| 660 if (!overwrite) { | |
| 661 FileId dest_parent_id; | |
| 662 if (!db->GetFileWithPath(VirtualPath::DirName(dest_url.path()), | |
| 663 &dest_parent_id)) { | |
| 664 return base::File::FILE_ERROR_NOT_FOUND; | |
| 665 } | |
| 666 if (!dest_file_info.is_directory()) | |
| 667 return base::File::FILE_ERROR_FAILED; | |
| 668 InitFileInfo(&dest_file_info, dest_parent_id, | |
| 669 VirtualPath::BaseName(dest_url.path()).value()); | |
| 670 } | |
| 671 | |
| 672 int64 growth = src_platform_file_info.size; | |
| 673 if (overwrite) | |
| 674 growth -= dest_platform_file_info.size; | |
| 675 else | |
| 676 growth += UsageForPath(dest_file_info.name.size()); | |
| 677 if (!AllocateQuota(context, growth)) | |
| 678 return base::File::FILE_ERROR_NO_SPACE; | |
| 679 | |
| 680 base::File::Error error; | |
| 681 if (overwrite) { | |
| 682 base::FilePath dest_local_path = | |
| 683 DataPathToLocalPath(dest_url, dest_file_info.data_path); | |
| 684 error = NativeFileUtil::CopyOrMoveFile( | |
| 685 src_file_path, dest_local_path, | |
| 686 FileSystemOperation::OPTION_NONE, | |
| 687 fileapi::NativeFileUtil::CopyOrMoveModeForDestination(dest_url, | |
| 688 true /* copy */)); | |
| 689 } else { | |
| 690 error = CreateFile(context, src_file_path, dest_url, &dest_file_info); | |
| 691 } | |
| 692 | |
| 693 if (error != base::File::FILE_OK) | |
| 694 return error; | |
| 695 | |
| 696 if (overwrite) { | |
| 697 context->change_observers()->Notify( | |
| 698 &FileChangeObserver::OnModifyFile, MakeTuple(dest_url)); | |
| 699 } else { | |
| 700 context->change_observers()->Notify( | |
| 701 &FileChangeObserver::OnCreateFile, MakeTuple(dest_url)); | |
| 702 } | |
| 703 | |
| 704 UpdateUsage(context, dest_url, growth); | |
| 705 TouchDirectory(db, dest_file_info.parent_id); | |
| 706 return base::File::FILE_OK; | |
| 707 } | |
| 708 | |
| 709 base::File::Error ObfuscatedFileUtil::DeleteFile( | |
| 710 FileSystemOperationContext* context, | |
| 711 const FileSystemURL& url) { | |
| 712 SandboxDirectoryDatabase* db = GetDirectoryDatabase(url, true); | |
| 713 if (!db) | |
| 714 return base::File::FILE_ERROR_FAILED; | |
| 715 FileId file_id; | |
| 716 if (!db->GetFileWithPath(url.path(), &file_id)) | |
| 717 return base::File::FILE_ERROR_NOT_FOUND; | |
| 718 | |
| 719 FileInfo file_info; | |
| 720 base::File::Info platform_file_info; | |
| 721 base::FilePath local_path; | |
| 722 base::File::Error error = GetFileInfoInternal( | |
| 723 db, context, url, file_id, &file_info, &platform_file_info, &local_path); | |
| 724 if (error != base::File::FILE_ERROR_NOT_FOUND && | |
| 725 error != base::File::FILE_OK) | |
| 726 return error; | |
| 727 | |
| 728 if (file_info.is_directory()) | |
| 729 return base::File::FILE_ERROR_NOT_A_FILE; | |
| 730 | |
| 731 int64 growth = -UsageForPath(file_info.name.size()) - platform_file_info.size; | |
| 732 AllocateQuota(context, growth); | |
| 733 if (!db->RemoveFileInfo(file_id)) { | |
| 734 NOTREACHED(); | |
| 735 return base::File::FILE_ERROR_FAILED; | |
| 736 } | |
| 737 UpdateUsage(context, url, growth); | |
| 738 TouchDirectory(db, file_info.parent_id); | |
| 739 | |
| 740 context->change_observers()->Notify( | |
| 741 &FileChangeObserver::OnRemoveFile, MakeTuple(url)); | |
| 742 | |
| 743 if (error == base::File::FILE_ERROR_NOT_FOUND) | |
| 744 return base::File::FILE_OK; | |
| 745 | |
| 746 error = NativeFileUtil::DeleteFile(local_path); | |
| 747 if (base::File::FILE_OK != error) | |
| 748 LOG(WARNING) << "Leaked a backing file."; | |
| 749 return base::File::FILE_OK; | |
| 750 } | |
| 751 | |
| 752 base::File::Error ObfuscatedFileUtil::DeleteDirectory( | |
| 753 FileSystemOperationContext* context, | |
| 754 const FileSystemURL& url) { | |
| 755 SandboxDirectoryDatabase* db = GetDirectoryDatabase(url, true); | |
| 756 if (!db) | |
| 757 return base::File::FILE_ERROR_FAILED; | |
| 758 | |
| 759 FileId file_id; | |
| 760 if (!db->GetFileWithPath(url.path(), &file_id)) | |
| 761 return base::File::FILE_ERROR_NOT_FOUND; | |
| 762 FileInfo file_info; | |
| 763 if (!db->GetFileInfo(file_id, &file_info)) { | |
| 764 NOTREACHED(); | |
| 765 return base::File::FILE_ERROR_FAILED; | |
| 766 } | |
| 767 if (!file_info.is_directory()) | |
| 768 return base::File::FILE_ERROR_NOT_A_DIRECTORY; | |
| 769 if (!db->RemoveFileInfo(file_id)) | |
| 770 return base::File::FILE_ERROR_NOT_EMPTY; | |
| 771 int64 growth = -UsageForPath(file_info.name.size()); | |
| 772 AllocateQuota(context, growth); | |
| 773 UpdateUsage(context, url, growth); | |
| 774 TouchDirectory(db, file_info.parent_id); | |
| 775 context->change_observers()->Notify( | |
| 776 &FileChangeObserver::OnRemoveDirectory, MakeTuple(url)); | |
| 777 return base::File::FILE_OK; | |
| 778 } | |
| 779 | |
| 780 webkit_blob::ScopedFile ObfuscatedFileUtil::CreateSnapshotFile( | |
| 781 FileSystemOperationContext* context, | |
| 782 const FileSystemURL& url, | |
| 783 base::File::Error* error, | |
| 784 base::File::Info* file_info, | |
| 785 base::FilePath* platform_path) { | |
| 786 // We're just returning the local file information. | |
| 787 *error = GetFileInfo(context, url, file_info, platform_path); | |
| 788 if (*error == base::File::FILE_OK && file_info->is_directory) { | |
| 789 *file_info = base::File::Info(); | |
| 790 *error = base::File::FILE_ERROR_NOT_A_FILE; | |
| 791 } | |
| 792 return webkit_blob::ScopedFile(); | |
| 793 } | |
| 794 | |
| 795 scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator> | |
| 796 ObfuscatedFileUtil::CreateFileEnumerator( | |
| 797 FileSystemOperationContext* context, | |
| 798 const FileSystemURL& root_url, | |
| 799 bool recursive) { | |
| 800 SandboxDirectoryDatabase* db = GetDirectoryDatabase(root_url, false); | |
| 801 if (!db) { | |
| 802 return scoped_ptr<AbstractFileEnumerator>(new EmptyFileEnumerator()); | |
| 803 } | |
| 804 return scoped_ptr<AbstractFileEnumerator>( | |
| 805 new ObfuscatedFileEnumerator(db, context, this, root_url, recursive)); | |
| 806 } | |
| 807 | |
| 808 bool ObfuscatedFileUtil::IsDirectoryEmpty( | |
| 809 FileSystemOperationContext* context, | |
| 810 const FileSystemURL& url) { | |
| 811 SandboxDirectoryDatabase* db = GetDirectoryDatabase(url, false); | |
| 812 if (!db) | |
| 813 return true; // Not a great answer, but it's what others do. | |
| 814 FileId file_id; | |
| 815 if (!db->GetFileWithPath(url.path(), &file_id)) | |
| 816 return true; // Ditto. | |
| 817 FileInfo file_info; | |
| 818 if (!db->GetFileInfo(file_id, &file_info)) { | |
| 819 DCHECK(!file_id); | |
| 820 // It's the root directory and the database hasn't been initialized yet. | |
| 821 return true; | |
| 822 } | |
| 823 if (!file_info.is_directory()) | |
| 824 return true; | |
| 825 std::vector<FileId> children; | |
| 826 // TODO(ericu): This could easily be made faster with help from the database. | |
| 827 if (!db->ListChildren(file_id, &children)) | |
| 828 return true; | |
| 829 return children.empty(); | |
| 830 } | |
| 831 | |
| 832 base::FilePath ObfuscatedFileUtil::GetDirectoryForOriginAndType( | |
| 833 const GURL& origin, | |
| 834 const std::string& type_string, | |
| 835 bool create, | |
| 836 base::File::Error* error_code) { | |
| 837 base::FilePath origin_dir = GetDirectoryForOrigin(origin, create, error_code); | |
| 838 if (origin_dir.empty()) | |
| 839 return base::FilePath(); | |
| 840 if (type_string.empty()) | |
| 841 return origin_dir; | |
| 842 base::FilePath path = origin_dir.AppendASCII(type_string); | |
| 843 base::File::Error error = base::File::FILE_OK; | |
| 844 if (!base::DirectoryExists(path) && | |
| 845 (!create || !base::CreateDirectory(path))) { | |
| 846 error = create ? | |
| 847 base::File::FILE_ERROR_FAILED : | |
| 848 base::File::FILE_ERROR_NOT_FOUND; | |
| 849 } | |
| 850 | |
| 851 if (error_code) | |
| 852 *error_code = error; | |
| 853 return path; | |
| 854 } | |
| 855 | |
| 856 bool ObfuscatedFileUtil::DeleteDirectoryForOriginAndType( | |
| 857 const GURL& origin, | |
| 858 const std::string& type_string) { | |
| 859 base::File::Error error = base::File::FILE_OK; | |
| 860 base::FilePath origin_type_path = GetDirectoryForOriginAndType( | |
| 861 origin, type_string, false, &error); | |
| 862 if (origin_type_path.empty()) | |
| 863 return true; | |
| 864 if (error != base::File::FILE_ERROR_NOT_FOUND) { | |
| 865 // TODO(dmikurube): Consider the return value of DestroyDirectoryDatabase. | |
| 866 // We ignore its error now since 1) it doesn't matter the final result, and | |
| 867 // 2) it always returns false in Windows because of LevelDB's | |
| 868 // implementation. | |
| 869 // Information about failure would be useful for debugging. | |
| 870 if (!type_string.empty()) | |
| 871 DestroyDirectoryDatabase(origin, type_string); | |
| 872 if (!base::DeleteFile(origin_type_path, true /* recursive */)) | |
| 873 return false; | |
| 874 } | |
| 875 | |
| 876 base::FilePath origin_path = VirtualPath::DirName(origin_type_path); | |
| 877 DCHECK_EQ(origin_path.value(), | |
| 878 GetDirectoryForOrigin(origin, false, NULL).value()); | |
| 879 | |
| 880 if (!type_string.empty()) { | |
| 881 // At this point we are sure we had successfully deleted the origin/type | |
| 882 // directory (i.e. we're ready to just return true). | |
| 883 // See if we have other directories in this origin directory. | |
| 884 for (std::set<std::string>::iterator iter = known_type_strings_.begin(); | |
| 885 iter != known_type_strings_.end(); | |
| 886 ++iter) { | |
| 887 if (*iter == type_string) | |
| 888 continue; | |
| 889 if (base::DirectoryExists(origin_path.AppendASCII(*iter))) { | |
| 890 // Other type's directory exists; just return true here. | |
| 891 return true; | |
| 892 } | |
| 893 } | |
| 894 } | |
| 895 | |
| 896 // No other directories seem exist. Try deleting the entire origin directory. | |
| 897 InitOriginDatabase(origin, false); | |
| 898 if (origin_database_) { | |
| 899 origin_database_->RemovePathForOrigin( | |
| 900 webkit_database::GetIdentifierFromOrigin(origin)); | |
| 901 } | |
| 902 if (!base::DeleteFile(origin_path, true /* recursive */)) | |
| 903 return false; | |
| 904 | |
| 905 return true; | |
| 906 } | |
| 907 | |
| 908 ObfuscatedFileUtil::AbstractOriginEnumerator* | |
| 909 ObfuscatedFileUtil::CreateOriginEnumerator() { | |
| 910 std::vector<SandboxOriginDatabase::OriginRecord> origins; | |
| 911 | |
| 912 InitOriginDatabase(GURL(), false); | |
| 913 return new ObfuscatedOriginEnumerator( | |
| 914 origin_database_.get(), file_system_directory_); | |
| 915 } | |
| 916 | |
| 917 bool ObfuscatedFileUtil::DestroyDirectoryDatabase( | |
| 918 const GURL& origin, | |
| 919 const std::string& type_string) { | |
| 920 std::string key = GetDirectoryDatabaseKey(origin, type_string); | |
| 921 if (key.empty()) | |
| 922 return true; | |
| 923 DirectoryMap::iterator iter = directories_.find(key); | |
| 924 if (iter != directories_.end()) { | |
| 925 SandboxDirectoryDatabase* database = iter->second; | |
| 926 directories_.erase(iter); | |
| 927 delete database; | |
| 928 } | |
| 929 | |
| 930 base::File::Error error = base::File::FILE_OK; | |
| 931 base::FilePath path = GetDirectoryForOriginAndType( | |
| 932 origin, type_string, false, &error); | |
| 933 if (path.empty() || error == base::File::FILE_ERROR_NOT_FOUND) | |
| 934 return true; | |
| 935 return SandboxDirectoryDatabase::DestroyDatabase(path, env_override_); | |
| 936 } | |
| 937 | |
| 938 // static | |
| 939 int64 ObfuscatedFileUtil::ComputeFilePathCost(const base::FilePath& path) { | |
| 940 return UsageForPath(VirtualPath::BaseName(path).value().size()); | |
| 941 } | |
| 942 | |
| 943 void ObfuscatedFileUtil::MaybePrepopulateDatabase( | |
| 944 const std::vector<std::string>& type_strings_to_prepopulate) { | |
| 945 SandboxPrioritizedOriginDatabase database(file_system_directory_, | |
| 946 env_override_); | |
| 947 std::string origin_string = database.GetPrimaryOrigin(); | |
| 948 if (origin_string.empty() || !database.HasOriginPath(origin_string)) | |
| 949 return; | |
| 950 const GURL origin = webkit_database::GetOriginFromIdentifier(origin_string); | |
| 951 | |
| 952 // Prepopulate the directory database(s) if and only if this instance | |
| 953 // has primary origin and the directory database is already there. | |
| 954 for (size_t i = 0; i < type_strings_to_prepopulate.size(); ++i) { | |
| 955 const std::string type_string = type_strings_to_prepopulate[i]; | |
| 956 // Only handles known types. | |
| 957 if (!ContainsKey(known_type_strings_, type_string)) | |
| 958 continue; | |
| 959 base::File::Error error = base::File::FILE_ERROR_FAILED; | |
| 960 base::FilePath path = GetDirectoryForOriginAndType( | |
| 961 origin, type_string, false, &error); | |
| 962 if (error != base::File::FILE_OK) | |
| 963 continue; | |
| 964 scoped_ptr<SandboxDirectoryDatabase> db( | |
| 965 new SandboxDirectoryDatabase(path, env_override_)); | |
| 966 if (db->Init(SandboxDirectoryDatabase::FAIL_ON_CORRUPTION)) { | |
| 967 directories_[GetDirectoryDatabaseKey(origin, type_string)] = db.release(); | |
| 968 MarkUsed(); | |
| 969 // Don't populate more than one database, as it may rather hurt | |
| 970 // performance. | |
| 971 break; | |
| 972 } | |
| 973 } | |
| 974 } | |
| 975 | |
| 976 base::FilePath ObfuscatedFileUtil::GetDirectoryForURL( | |
| 977 const FileSystemURL& url, | |
| 978 bool create, | |
| 979 base::File::Error* error_code) { | |
| 980 return GetDirectoryForOriginAndType( | |
| 981 url.origin(), CallGetTypeStringForURL(url), create, error_code); | |
| 982 } | |
| 983 | |
| 984 std::string ObfuscatedFileUtil::CallGetTypeStringForURL( | |
| 985 const FileSystemURL& url) { | |
| 986 DCHECK(!get_type_string_for_url_.is_null()); | |
| 987 return get_type_string_for_url_.Run(url); | |
| 988 } | |
| 989 | |
| 990 base::File::Error ObfuscatedFileUtil::GetFileInfoInternal( | |
| 991 SandboxDirectoryDatabase* db, | |
| 992 FileSystemOperationContext* context, | |
| 993 const FileSystemURL& url, | |
| 994 FileId file_id, | |
| 995 FileInfo* local_info, | |
| 996 base::File::Info* file_info, | |
| 997 base::FilePath* platform_file_path) { | |
| 998 DCHECK(db); | |
| 999 DCHECK(context); | |
| 1000 DCHECK(file_info); | |
| 1001 DCHECK(platform_file_path); | |
| 1002 | |
| 1003 if (!db->GetFileInfo(file_id, local_info)) { | |
| 1004 NOTREACHED(); | |
| 1005 return base::File::FILE_ERROR_FAILED; | |
| 1006 } | |
| 1007 | |
| 1008 if (local_info->is_directory()) { | |
| 1009 file_info->size = 0; | |
| 1010 file_info->is_directory = true; | |
| 1011 file_info->is_symbolic_link = false; | |
| 1012 file_info->last_modified = local_info->modification_time; | |
| 1013 *platform_file_path = base::FilePath(); | |
| 1014 // We don't fill in ctime or atime. | |
| 1015 return base::File::FILE_OK; | |
| 1016 } | |
| 1017 if (local_info->data_path.empty()) | |
| 1018 return base::File::FILE_ERROR_INVALID_OPERATION; | |
| 1019 base::FilePath local_path = DataPathToLocalPath(url, local_info->data_path); | |
| 1020 base::File::Error error = NativeFileUtil::GetFileInfo( | |
| 1021 local_path, file_info); | |
| 1022 // We should not follow symbolic links in sandboxed file system. | |
| 1023 if (base::IsLink(local_path)) { | |
| 1024 LOG(WARNING) << "Found a symbolic file."; | |
| 1025 error = base::File::FILE_ERROR_NOT_FOUND; | |
| 1026 } | |
| 1027 if (error == base::File::FILE_OK) { | |
| 1028 *platform_file_path = local_path; | |
| 1029 } else if (error == base::File::FILE_ERROR_NOT_FOUND) { | |
| 1030 LOG(WARNING) << "Lost a backing file."; | |
| 1031 InvalidateUsageCache(context, url.origin(), url.type()); | |
| 1032 if (!db->RemoveFileInfo(file_id)) | |
| 1033 return base::File::FILE_ERROR_FAILED; | |
| 1034 } | |
| 1035 return error; | |
| 1036 } | |
| 1037 | |
| 1038 base::File ObfuscatedFileUtil::CreateAndOpenFile( | |
| 1039 FileSystemOperationContext* context, | |
| 1040 const FileSystemURL& dest_url, | |
| 1041 FileInfo* dest_file_info, int file_flags) { | |
| 1042 SandboxDirectoryDatabase* db = GetDirectoryDatabase(dest_url, true); | |
| 1043 | |
| 1044 base::FilePath root, dest_local_path; | |
| 1045 base::File::Error error = GenerateNewLocalPath(db, context, dest_url, &root, | |
| 1046 &dest_local_path); | |
| 1047 if (error != base::File::FILE_OK) | |
| 1048 return base::File(error); | |
| 1049 | |
| 1050 if (base::PathExists(dest_local_path)) { | |
| 1051 if (!base::DeleteFile(dest_local_path, true /* recursive */)) | |
| 1052 return base::File(base::File::FILE_ERROR_FAILED); | |
| 1053 LOG(WARNING) << "A stray file detected"; | |
| 1054 InvalidateUsageCache(context, dest_url.origin(), dest_url.type()); | |
| 1055 } | |
| 1056 | |
| 1057 base::File file = NativeFileUtil::CreateOrOpen(dest_local_path, file_flags); | |
| 1058 if (!file.IsValid()) | |
| 1059 return file.Pass(); | |
| 1060 | |
| 1061 if (!file.created()) { | |
| 1062 file.Close(); | |
| 1063 base::DeleteFile(dest_local_path, false /* recursive */); | |
| 1064 return base::File(base::File::FILE_ERROR_FAILED); | |
| 1065 } | |
| 1066 | |
| 1067 error = CommitCreateFile(root, dest_local_path, db, dest_file_info); | |
| 1068 if (error != base::File::FILE_OK) { | |
| 1069 file.Close(); | |
| 1070 base::DeleteFile(dest_local_path, false /* recursive */); | |
| 1071 return base::File(error); | |
| 1072 } | |
| 1073 | |
| 1074 return file.Pass(); | |
| 1075 } | |
| 1076 | |
| 1077 base::File::Error ObfuscatedFileUtil::CreateFile( | |
| 1078 FileSystemOperationContext* context, | |
| 1079 const base::FilePath& src_file_path, | |
| 1080 const FileSystemURL& dest_url, | |
| 1081 FileInfo* dest_file_info) { | |
| 1082 SandboxDirectoryDatabase* db = GetDirectoryDatabase(dest_url, true); | |
| 1083 | |
| 1084 base::FilePath root, dest_local_path; | |
| 1085 base::File::Error error = GenerateNewLocalPath(db, context, dest_url, &root, | |
| 1086 &dest_local_path); | |
| 1087 if (error != base::File::FILE_OK) | |
| 1088 return error; | |
| 1089 | |
| 1090 bool created = false; | |
| 1091 if (src_file_path.empty()) { | |
| 1092 if (base::PathExists(dest_local_path)) { | |
| 1093 if (!base::DeleteFile(dest_local_path, true /* recursive */)) | |
| 1094 return base::File::FILE_ERROR_FAILED; | |
| 1095 LOG(WARNING) << "A stray file detected"; | |
| 1096 InvalidateUsageCache(context, dest_url.origin(), dest_url.type()); | |
| 1097 } | |
| 1098 | |
| 1099 error = NativeFileUtil::EnsureFileExists(dest_local_path, &created); | |
| 1100 } else { | |
| 1101 error = NativeFileUtil::CopyOrMoveFile( | |
| 1102 src_file_path, dest_local_path, | |
| 1103 FileSystemOperation::OPTION_NONE, | |
| 1104 fileapi::NativeFileUtil::CopyOrMoveModeForDestination(dest_url, | |
| 1105 true /* copy */)); | |
| 1106 created = true; | |
| 1107 } | |
| 1108 if (error != base::File::FILE_OK) | |
| 1109 return error; | |
| 1110 if (!created) | |
| 1111 return base::File::FILE_ERROR_FAILED; | |
| 1112 | |
| 1113 return CommitCreateFile(root, dest_local_path, db, dest_file_info); | |
| 1114 } | |
| 1115 | |
| 1116 base::File::Error ObfuscatedFileUtil::CommitCreateFile( | |
| 1117 const base::FilePath& root, | |
| 1118 const base::FilePath& local_path, | |
| 1119 SandboxDirectoryDatabase* db, | |
| 1120 FileInfo* dest_file_info) { | |
| 1121 // This removes the root, including the trailing slash, leaving a relative | |
| 1122 // path. | |
| 1123 dest_file_info->data_path = base::FilePath( | |
| 1124 local_path.value().substr(root.value().length() + 1)); | |
| 1125 | |
| 1126 FileId file_id; | |
| 1127 base::File::Error error = db->AddFileInfo(*dest_file_info, &file_id); | |
| 1128 if (error != base::File::FILE_OK) | |
| 1129 return error; | |
| 1130 | |
| 1131 TouchDirectory(db, dest_file_info->parent_id); | |
| 1132 return base::File::FILE_OK; | |
| 1133 } | |
| 1134 | |
| 1135 base::FilePath ObfuscatedFileUtil::DataPathToLocalPath( | |
| 1136 const FileSystemURL& url, const base::FilePath& data_path) { | |
| 1137 base::File::Error error = base::File::FILE_OK; | |
| 1138 base::FilePath root = GetDirectoryForURL(url, false, &error); | |
| 1139 if (error != base::File::FILE_OK) | |
| 1140 return base::FilePath(); | |
| 1141 return root.Append(data_path); | |
| 1142 } | |
| 1143 | |
| 1144 std::string ObfuscatedFileUtil::GetDirectoryDatabaseKey( | |
| 1145 const GURL& origin, const std::string& type_string) { | |
| 1146 if (type_string.empty()) { | |
| 1147 LOG(WARNING) << "Unknown filesystem type requested:" << type_string; | |
| 1148 return std::string(); | |
| 1149 } | |
| 1150 // For isolated origin we just use a type string as a key. | |
| 1151 return webkit_database::GetIdentifierFromOrigin(origin) + | |
| 1152 type_string; | |
| 1153 } | |
| 1154 | |
| 1155 // TODO(ericu): How to do the whole validation-without-creation thing? | |
| 1156 // We may not have quota even to create the database. | |
| 1157 // Ah, in that case don't even get here? | |
| 1158 // Still doesn't answer the quota issue, though. | |
| 1159 SandboxDirectoryDatabase* ObfuscatedFileUtil::GetDirectoryDatabase( | |
| 1160 const FileSystemURL& url, bool create) { | |
| 1161 std::string key = GetDirectoryDatabaseKey( | |
| 1162 url.origin(), CallGetTypeStringForURL(url)); | |
| 1163 if (key.empty()) | |
| 1164 return NULL; | |
| 1165 | |
| 1166 DirectoryMap::iterator iter = directories_.find(key); | |
| 1167 if (iter != directories_.end()) { | |
| 1168 MarkUsed(); | |
| 1169 return iter->second; | |
| 1170 } | |
| 1171 | |
| 1172 base::File::Error error = base::File::FILE_OK; | |
| 1173 base::FilePath path = GetDirectoryForURL(url, create, &error); | |
| 1174 if (error != base::File::FILE_OK) { | |
| 1175 LOG(WARNING) << "Failed to get origin+type directory: " | |
| 1176 << url.DebugString() << " error:" << error; | |
| 1177 return NULL; | |
| 1178 } | |
| 1179 MarkUsed(); | |
| 1180 SandboxDirectoryDatabase* database = | |
| 1181 new SandboxDirectoryDatabase(path, env_override_); | |
| 1182 directories_[key] = database; | |
| 1183 return database; | |
| 1184 } | |
| 1185 | |
| 1186 base::FilePath ObfuscatedFileUtil::GetDirectoryForOrigin( | |
| 1187 const GURL& origin, bool create, base::File::Error* error_code) { | |
| 1188 if (!InitOriginDatabase(origin, create)) { | |
| 1189 if (error_code) { | |
| 1190 *error_code = create ? | |
| 1191 base::File::FILE_ERROR_FAILED : | |
| 1192 base::File::FILE_ERROR_NOT_FOUND; | |
| 1193 } | |
| 1194 return base::FilePath(); | |
| 1195 } | |
| 1196 base::FilePath directory_name; | |
| 1197 std::string id = webkit_database::GetIdentifierFromOrigin(origin); | |
| 1198 | |
| 1199 bool exists_in_db = origin_database_->HasOriginPath(id); | |
| 1200 if (!exists_in_db && !create) { | |
| 1201 if (error_code) | |
| 1202 *error_code = base::File::FILE_ERROR_NOT_FOUND; | |
| 1203 return base::FilePath(); | |
| 1204 } | |
| 1205 if (!origin_database_->GetPathForOrigin(id, &directory_name)) { | |
| 1206 if (error_code) | |
| 1207 *error_code = base::File::FILE_ERROR_FAILED; | |
| 1208 return base::FilePath(); | |
| 1209 } | |
| 1210 | |
| 1211 base::FilePath path = file_system_directory_.Append(directory_name); | |
| 1212 bool exists_in_fs = base::DirectoryExists(path); | |
| 1213 if (!exists_in_db && exists_in_fs) { | |
| 1214 if (!base::DeleteFile(path, true)) { | |
| 1215 if (error_code) | |
| 1216 *error_code = base::File::FILE_ERROR_FAILED; | |
| 1217 return base::FilePath(); | |
| 1218 } | |
| 1219 exists_in_fs = false; | |
| 1220 } | |
| 1221 | |
| 1222 if (!exists_in_fs) { | |
| 1223 if (!create || !base::CreateDirectory(path)) { | |
| 1224 if (error_code) | |
| 1225 *error_code = create ? | |
| 1226 base::File::FILE_ERROR_FAILED : | |
| 1227 base::File::FILE_ERROR_NOT_FOUND; | |
| 1228 return base::FilePath(); | |
| 1229 } | |
| 1230 } | |
| 1231 | |
| 1232 if (error_code) | |
| 1233 *error_code = base::File::FILE_OK; | |
| 1234 | |
| 1235 return path; | |
| 1236 } | |
| 1237 | |
| 1238 void ObfuscatedFileUtil::InvalidateUsageCache( | |
| 1239 FileSystemOperationContext* context, | |
| 1240 const GURL& origin, | |
| 1241 FileSystemType type) { | |
| 1242 if (sandbox_delegate_) | |
| 1243 sandbox_delegate_->InvalidateUsageCache(origin, type); | |
| 1244 } | |
| 1245 | |
| 1246 void ObfuscatedFileUtil::MarkUsed() { | |
| 1247 if (!timer_) | |
| 1248 timer_.reset(new TimedTaskHelper(file_task_runner_.get())); | |
| 1249 | |
| 1250 if (timer_->IsRunning()) { | |
| 1251 timer_->Reset(); | |
| 1252 } else { | |
| 1253 timer_->Start(FROM_HERE, | |
| 1254 base::TimeDelta::FromSeconds(db_flush_delay_seconds_), | |
| 1255 base::Bind(&ObfuscatedFileUtil::DropDatabases, | |
| 1256 base::Unretained(this))); | |
| 1257 } | |
| 1258 } | |
| 1259 | |
| 1260 void ObfuscatedFileUtil::DropDatabases() { | |
| 1261 origin_database_.reset(); | |
| 1262 STLDeleteContainerPairSecondPointers( | |
| 1263 directories_.begin(), directories_.end()); | |
| 1264 directories_.clear(); | |
| 1265 timer_.reset(); | |
| 1266 } | |
| 1267 | |
| 1268 bool ObfuscatedFileUtil::InitOriginDatabase(const GURL& origin_hint, | |
| 1269 bool create) { | |
| 1270 if (origin_database_) | |
| 1271 return true; | |
| 1272 | |
| 1273 if (!create && !base::DirectoryExists(file_system_directory_)) | |
| 1274 return false; | |
| 1275 if (!base::CreateDirectory(file_system_directory_)) { | |
| 1276 LOG(WARNING) << "Failed to create FileSystem directory: " << | |
| 1277 file_system_directory_.value(); | |
| 1278 return false; | |
| 1279 } | |
| 1280 | |
| 1281 SandboxPrioritizedOriginDatabase* prioritized_origin_database = | |
| 1282 new SandboxPrioritizedOriginDatabase(file_system_directory_, | |
| 1283 env_override_); | |
| 1284 origin_database_.reset(prioritized_origin_database); | |
| 1285 | |
| 1286 if (origin_hint.is_empty() || !HasIsolatedStorage(origin_hint)) | |
| 1287 return true; | |
| 1288 | |
| 1289 const std::string isolated_origin_string = | |
| 1290 webkit_database::GetIdentifierFromOrigin(origin_hint); | |
| 1291 | |
| 1292 // TODO(kinuko): Deprecate this after a few release cycles, e.g. around M33. | |
| 1293 base::FilePath isolated_origin_dir = file_system_directory_.Append( | |
| 1294 SandboxIsolatedOriginDatabase::kObsoleteOriginDirectory); | |
| 1295 if (base::DirectoryExists(isolated_origin_dir) && | |
| 1296 prioritized_origin_database->GetSandboxOriginDatabase()) { | |
| 1297 SandboxIsolatedOriginDatabase::MigrateBackFromObsoleteOriginDatabase( | |
| 1298 isolated_origin_string, | |
| 1299 file_system_directory_, | |
| 1300 prioritized_origin_database->GetSandboxOriginDatabase()); | |
| 1301 } | |
| 1302 | |
| 1303 prioritized_origin_database->InitializePrimaryOrigin( | |
| 1304 isolated_origin_string); | |
| 1305 | |
| 1306 return true; | |
| 1307 } | |
| 1308 | |
| 1309 base::File::Error ObfuscatedFileUtil::GenerateNewLocalPath( | |
| 1310 SandboxDirectoryDatabase* db, | |
| 1311 FileSystemOperationContext* context, | |
| 1312 const FileSystemURL& url, | |
| 1313 base::FilePath* root, | |
| 1314 base::FilePath* local_path) { | |
| 1315 DCHECK(local_path); | |
| 1316 int64 number; | |
| 1317 if (!db || !db->GetNextInteger(&number)) | |
| 1318 return base::File::FILE_ERROR_FAILED; | |
| 1319 | |
| 1320 base::File::Error error = base::File::FILE_OK; | |
| 1321 *root = GetDirectoryForURL(url, false, &error); | |
| 1322 if (error != base::File::FILE_OK) | |
| 1323 return error; | |
| 1324 | |
| 1325 // We use the third- and fourth-to-last digits as the directory. | |
| 1326 int64 directory_number = number % 10000 / 100; | |
| 1327 base::FilePath new_local_path = root->AppendASCII( | |
| 1328 base::StringPrintf("%02" PRId64, directory_number)); | |
| 1329 | |
| 1330 error = NativeFileUtil::CreateDirectory( | |
| 1331 new_local_path, false /* exclusive */, false /* recursive */); | |
| 1332 if (error != base::File::FILE_OK) | |
| 1333 return error; | |
| 1334 | |
| 1335 *local_path = | |
| 1336 new_local_path.AppendASCII(base::StringPrintf("%08" PRId64, number)); | |
| 1337 return base::File::FILE_OK; | |
| 1338 } | |
| 1339 | |
| 1340 base::File ObfuscatedFileUtil::CreateOrOpenInternal( | |
| 1341 FileSystemOperationContext* context, | |
| 1342 const FileSystemURL& url, int file_flags) { | |
| 1343 DCHECK(!(file_flags & (base::File::FLAG_DELETE_ON_CLOSE | | |
| 1344 base::File::FLAG_HIDDEN | base::File::FLAG_EXCLUSIVE_READ | | |
| 1345 base::File::FLAG_EXCLUSIVE_WRITE))); | |
| 1346 SandboxDirectoryDatabase* db = GetDirectoryDatabase(url, true); | |
| 1347 if (!db) | |
| 1348 return base::File(base::File::FILE_ERROR_FAILED); | |
| 1349 FileId file_id; | |
| 1350 if (!db->GetFileWithPath(url.path(), &file_id)) { | |
| 1351 // The file doesn't exist. | |
| 1352 if (!(file_flags & (base::File::FLAG_CREATE | | |
| 1353 base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_OPEN_ALWAYS))) { | |
| 1354 return base::File(base::File::FILE_ERROR_NOT_FOUND); | |
| 1355 } | |
| 1356 FileId parent_id; | |
| 1357 if (!db->GetFileWithPath(VirtualPath::DirName(url.path()), &parent_id)) | |
| 1358 return base::File(base::File::FILE_ERROR_NOT_FOUND); | |
| 1359 FileInfo file_info; | |
| 1360 InitFileInfo(&file_info, parent_id, | |
| 1361 VirtualPath::BaseName(url.path()).value()); | |
| 1362 | |
| 1363 int64 growth = UsageForPath(file_info.name.size()); | |
| 1364 if (!AllocateQuota(context, growth)) | |
| 1365 return base::File(base::File::FILE_ERROR_NO_SPACE); | |
| 1366 base::File file = CreateAndOpenFile(context, url, &file_info, file_flags); | |
| 1367 if (file.IsValid()) { | |
| 1368 UpdateUsage(context, url, growth); | |
| 1369 context->change_observers()->Notify( | |
| 1370 &FileChangeObserver::OnCreateFile, MakeTuple(url)); | |
| 1371 } | |
| 1372 return file.Pass(); | |
| 1373 } | |
| 1374 | |
| 1375 if (file_flags & base::File::FLAG_CREATE) | |
| 1376 return base::File(base::File::FILE_ERROR_EXISTS); | |
| 1377 | |
| 1378 base::File::Info platform_file_info; | |
| 1379 base::FilePath local_path; | |
| 1380 FileInfo file_info; | |
| 1381 base::File::Error error = GetFileInfoInternal( | |
| 1382 db, context, url, file_id, &file_info, &platform_file_info, &local_path); | |
| 1383 if (error != base::File::FILE_OK) | |
| 1384 return base::File(error); | |
| 1385 if (file_info.is_directory()) | |
| 1386 return base::File(base::File::FILE_ERROR_NOT_A_FILE); | |
| 1387 | |
| 1388 int64 delta = 0; | |
| 1389 if (file_flags & (base::File::FLAG_CREATE_ALWAYS | | |
| 1390 base::File::FLAG_OPEN_TRUNCATED)) { | |
| 1391 // The file exists and we're truncating. | |
| 1392 delta = -platform_file_info.size; | |
| 1393 AllocateQuota(context, delta); | |
| 1394 } | |
| 1395 | |
| 1396 base::File file = NativeFileUtil::CreateOrOpen(local_path, file_flags); | |
| 1397 if (!file.IsValid()) { | |
| 1398 error = file.error_details(); | |
| 1399 if (error == base::File::FILE_ERROR_NOT_FOUND) { | |
| 1400 // TODO(tzik): Also invalidate on-memory usage cache in UsageTracker. | |
| 1401 // TODO(tzik): Delete database entry after ensuring the file lost. | |
| 1402 InvalidateUsageCache(context, url.origin(), url.type()); | |
| 1403 LOG(WARNING) << "Lost a backing file."; | |
| 1404 return base::File(base::File::FILE_ERROR_FAILED); | |
| 1405 } | |
| 1406 return file.Pass(); | |
| 1407 } | |
| 1408 | |
| 1409 // If truncating we need to update the usage. | |
| 1410 if (delta) { | |
| 1411 UpdateUsage(context, url, delta); | |
| 1412 context->change_observers()->Notify( | |
| 1413 &FileChangeObserver::OnModifyFile, MakeTuple(url)); | |
| 1414 } | |
| 1415 return file.Pass(); | |
| 1416 } | |
| 1417 | |
| 1418 bool ObfuscatedFileUtil::HasIsolatedStorage(const GURL& origin) { | |
| 1419 return special_storage_policy_.get() && | |
| 1420 special_storage_policy_->HasIsolatedStorage(origin); | |
| 1421 } | |
| 1422 | |
| 1423 } // namespace fileapi | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 442383002:
Move storage-related files from webkit/ to new top-level directory storage/ (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src