Home | History | Annotate | Download | only in fileapi 
      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::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
   1424