webkit/browser/fileapi/obfuscated_file_util.cc

   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, &current_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::PLATFORM_FILE_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