Handle inconsistency between DB and Files

webkit/fileapi/obfuscated_file_system_file_util.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "webkit/fileapi/obfuscated_file_system_file_util.h"
 
 #include <queue>
 #include <vector>
 
 #include "base/file_util.h"
@@ skipping 61 matching lines @@
     PlatformFile* file_handle, bool* created) {
   DCHECK(!(file_flags & (base::PLATFORM_FILE_DELETE_ON_CLOSE |
         base::PLATFORM_FILE_HIDDEN | base::PLATFORM_FILE_EXCLUSIVE_READ |
         base::PLATFORM_FILE_EXCLUSIVE_WRITE)));
   FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
       context->src_origin_url(), context->src_type(), true);
   if (!db)
     return base::PLATFORM_FILE_ERROR_FAILED;
   FileId file_id;
   if (!db->GetFileWithPath(virtual_path, &file_id)) {
-    // The file doesn't exist.
+    // The file doesn't exist in the database.
     if (!(file_flags & (base::PLATFORM_FILE_CREATE |
         base::PLATFORM_FILE_CREATE_ALWAYS | base::PLATFORM_FILE_OPEN_ALWAYS)))
       return base::PLATFORM_FILE_ERROR_NOT_FOUND;
     FileId parent_id;
     if (!db->GetFileWithPath(virtual_path.DirName(), &parent_id))
       return base::PLATFORM_FILE_ERROR_NOT_FOUND;
     FileInfo file_info;
     InitFileInfo(&file_info, parent_id, virtual_path.BaseName().value());
+
+    // There may be a file without database entry out of inconsistency between
+    // actual filesystem and database.  We use PLATFORM_FILE_CREATE_ALWAYS
+    // to truncate such file.
+    file_flags &= ~(base::PLATFORM_FILE_OPEN |
+                    base::PLATFORM_FILE_CREATE |
+                    base::PLATFORM_FILE_OPEN_TRUNCATED);
+    file_flags |= base::PLATFORM_FILE_CREATE_ALWAYS |
+                  base::PLATFORM_FILE_OPEN_ALWAYS;

[ericu, 2011/08/10 17:28:01]

From platform_file.h:


// PLATFORM_FILE_(OPEN|CREATE).* are mutually exclusive. You should specify
// exactly one of the five (possibly combining with other flags) when opening
// or creating a file.


If the comment is wrong, it should be fixed.  If it's not wrong, then this code
is.

[tzik, 2011/08/16 08:25:33]

Yes, the patch went wrong way. It caused tests fail explicitly in windows.

     PlatformFileError error = CreateFile(
         context, context->src_origin_url(), context->src_type(), FilePath(),
         &file_info, file_flags, file_handle);
+    if (error == base::PLATFORM_FILE_ERROR_EXISTS)
+      error = base::PLATFORM_FILE_OK;
     if (created && base::PLATFORM_FILE_OK == error)
       *created = true;
     return error;
   }
   if (file_flags & base::PLATFORM_FILE_CREATE)
     return base::PLATFORM_FILE_ERROR_EXISTS;
 
   FileInfo file_info;
   if (!db->GetFileInfo(file_id, &file_info)) {
     NOTREACHED();
@@ skipping 684 matching lines @@
     created = true;
   } else {
     if (handle) {
       error = underlying_file_util_->CreateOrOpen(
         context, path, file_flags, handle, &created);
       // If this succeeds, we must close handle on any subsequent error.
     } else {
       DCHECK(!file_flags);  // file_flags is only used by CreateOrOpen.
       error = underlying_file_util_->EnsureFileExists(
           context, path, &created);
+
+      // If the file already exists, we found a stray file out of
+      // inconsistency between database and filesystem.  We should truncate
+      // it to empty.
+      if (error == base::PLATFORM_FILE_OK && !created) {
+        PlatformFile file = base::CreatePlatformFile(
+            path, base::PLATFORM_FILE_WRITE | base::PLATFORM_FILE_CREATE_ALWAYS,
+            &created, &error);
+        if (error == base::PLATFORM_FILE_ERROR_EXISTS)
+          error = base::PLATFORM_FILE_OK;
+        if (error == base::PLATFORM_FILE_OK) {
+          if (!base::ClosePlatformFile(file))
+            error = base::PLATFORM_FILE_ERROR_FAILED;
+        }
+      }
     }
   }
   if (error != base::PLATFORM_FILE_OK)
     return error;
 
   if (!created) {
     NOTREACHED();
     if (handle) {
       DCHECK_NE(base::kInvalidPlatformFileValue, *handle);
       base::ClosePlatformFile(*handle);
@@ skipping 217 matching lines @@
   directories_[key] = database;
   return database;
 }
 
 FilePath ObfuscatedFileSystemFileUtil::GetDirectoryForOrigin(
     const GURL& origin, bool create) {
   if (!InitOriginDatabase(create))
     return FilePath();
   FilePath directory_name;
   std::string id = GetOriginIdentifierFromURL(origin);
-  if (!create && !origin_database_->HasOriginPath(id))
+
+  bool exists_in_db = origin_database_->HasOriginPath(id);
+  if (!exists_in_db && !create)
     return FilePath();
   if (!origin_database_->GetPathForOrigin(id, &directory_name))
     return FilePath();
+
   FilePath path = file_system_directory_.Append(directory_name);
-  if (!file_util::DirectoryExists(path) &&
-      (!create || !file_util::CreateDirectory(path)))
-    return FilePath();
+  bool exists_in_fs = file_util::DirectoryExists(path);
+  if (!exists_in_db && exists_in_fs) {
+    if (!file_util::Delete(path, true))
+      return FilePath();
+    else
+      exists_in_fs = false;
+  }
+
+  if (!exists_in_fs) {
+    if (!create || !file_util::CreateDirectory(path))
+      return FilePath();
+  }
+
   return path;
 }
 
 void ObfuscatedFileSystemFileUtil::MarkUsed() {
   if (timer_.IsRunning())
     timer_.Reset();
   else
     timer_.Start(base::TimeDelta::FromSeconds(kFlushDelaySeconds), this,
       &ObfuscatedFileSystemFileUtil::DropDatabases);
 }
@@ skipping 40 matching lines @@
       return false;
     }
     origin_database_.reset(
         new FileSystemOriginDatabase(
             file_system_directory_.AppendASCII(kOriginDatabaseName)));
   }
   return true;
 }
 
 }  // namespace fileapi