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 137 matching lines @@
   if (file_flags & base::PLATFORM_FILE_CREATE)
     return base::PLATFORM_FILE_ERROR_EXISTS;
 
   FileInfo file_info;
   if (!db->GetFileInfo(file_id, &file_info)) {
     NOTREACHED();
     return base::PLATFORM_FILE_ERROR_FAILED;
   }
   if (file_info.is_directory())
     return base::PLATFORM_FILE_ERROR_NOT_A_FILE;
-  FilePath data_path = DataPathToLocalPath(context->src_origin_url(),
+  FilePath local_path = DataPathToLocalPath(context->src_origin_url(),
     context->src_type(), file_info.data_path);
-  return underlying_file_util_->CreateOrOpen(
-      context, data_path, file_flags, file_handle, created);
+  base::PlatformFileError error = underlying_file_util_->CreateOrOpen(
+      context, local_path, file_flags, file_handle, created);
+  if (error == base::PLATFORM_FILE_ERROR_NOT_FOUND) {
+    // TODO(tzik): Also invalidate on-memory usage cache in UsageTracker.
+    // TODO(tzik): Delete database entry after ensuring the file lost.
+    context->file_system_context()->GetQuotaUtil(context->src_type())->
+        InvalidateUsageCache(context->src_origin_url(),
+                             context->src_type());
+    LOG(WARNING) << "Lost a backing file.";
+    error = base::PLATFORM_FILE_ERROR_FAILED;
+  }
+  return error;
 }
 
 PlatformFileError ObfuscatedFileSystemFileUtil::EnsureFileExists(
     FileSystemOperationContext* context,
     const FilePath& virtual_path,
     bool* created) {
   FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
       context->src_origin_url(), context->src_type(), true);
   if (!db)
     return base::PLATFORM_FILE_ERROR_FAILED;
@@ skipping 206 matching lines @@
    *  transaction:
    *    Remove source entry.
    *    Point target entry to source entry's backing file.
    *  Delete target entry's old backing file
    * Move-without-overwrite
    *  Just update metadata
    */
   if (copy) {
     FilePath src_data_path = DataPathToLocalPath(context->src_origin_url(),
       context->src_type(), src_file_info.data_path);
+    if (!underlying_file_util_->PathExists(context, src_data_path)) {
+      // TODO(tzik): Also invalidate on-memory usage cache in UsageTracker.
+      context->file_system_context()->GetQuotaUtil(context->src_type())->
+          InvalidateUsageCache(context->src_origin_url(),
+                               context->src_type());
+      LOG(WARNING) << "Lost a backing file.";
+      return base::PLATFORM_FILE_ERROR_FAILED;
+    }
+
     if (overwrite) {
       FilePath dest_data_path = DataPathToLocalPath(context->src_origin_url(),
         context->src_type(), dest_file_info.data_path);
       return underlying_file_util_->CopyOrMoveFile(context,
           src_data_path, dest_data_path, copy);
     } else {
       FileId dest_parent_id;
       if (!db->GetFileWithPath(dest_file_path.DirName(), &dest_parent_id)) {
         NOTREACHED();  // We shouldn't be called in this case.
         return base::PLATFORM_FILE_ERROR_NOT_FOUND;
@@ skipping 419 matching lines @@
     FileInfo* file_info, int file_flags, PlatformFile* handle) {
   if (handle)
     *handle = base::kInvalidPlatformFileValue;
   FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
       origin_url, type, true);
   int64 number;
   if (!db || !db->GetNextInteger(&number))
     return base::PLATFORM_FILE_ERROR_FAILED;
   // We use the third- and fourth-to-last digits as the directory.
   int64 directory_number = number % 10000 / 100;
-  FilePath path =
+  // TODO(ericu): local_path is an OS path; underlying_file_util_ isn't
+  // guaranteed to understand OS paths.
+  FilePath local_path =
       GetDirectoryForOriginAndType(origin_url, type, false);
-  if (path.empty())
+  if (local_path.empty())
     return base::PLATFORM_FILE_ERROR_FAILED;
 
-  path = path.AppendASCII(StringPrintf("%02" PRIu64, directory_number));
+  local_path = local_path.AppendASCII(StringPrintf("%02" PRIu64,
+                                                   directory_number));
   PlatformFileError error;
   error = underlying_file_util_->CreateDirectory(
-      context, path, false /* exclusive */, false /* recursive */);
+      context, local_path, false /* exclusive */, false /* recursive */);
   if (base::PLATFORM_FILE_OK != error)
     return error;
-  path = path.AppendASCII(StringPrintf("%08" PRIu64, number));
-  FilePath data_path = LocalPathToDataPath(origin_url, type, path);
+  local_path = local_path.AppendASCII(StringPrintf("%08" PRIu64, number));
+  FilePath data_path = LocalPathToDataPath(origin_url, type, local_path);
   if (data_path.empty())
     return base::PLATFORM_FILE_ERROR_FAILED;
   bool created = false;
   if (!source_path.empty()) {
     DCHECK(!file_flags);
     DCHECK(!handle);
     error = underlying_file_util_->CopyOrMoveFile(
-      context, source_path, path, true /* copy */);
+      context, source_path, local_path, true /* copy */);
     created = true;
   } else {
+    FilePath path;
+    underlying_file_util_->GetLocalFilePath(context, local_path, &path);
+    if (file_util::PathExists(path)) {
+      if (!file_util::Delete(path, true)) {
+        NOTREACHED();
+        return base::PLATFORM_FILE_ERROR_FAILED;
+      }
+      LOG(WARNING) << "A stray file detected";
+      context->file_system_context()->GetQuotaUtil(context->src_type())->
+          InvalidateUsageCache(context->src_origin_url(), context->src_type());
+    }
+
     if (handle) {
       error = underlying_file_util_->CreateOrOpen(
-        context, path, file_flags, handle, &created);
+        context, local_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);
+          context, local_path, &created);
     }
   }
   if (error != base::PLATFORM_FILE_OK)
     return error;
 
   if (!created) {
     NOTREACHED();
     if (handle) {
       DCHECK_NE(base::kInvalidPlatformFileValue, *handle);
       base::ClosePlatformFile(*handle);
-      underlying_file_util_->DeleteFile(context, path);
+      underlying_file_util_->DeleteFile(context, local_path);
     }
     return base::PLATFORM_FILE_ERROR_FAILED;
   }
   file_info->data_path = data_path;
   FileId file_id;
   if (!db->AddFileInfo(*file_info, &file_id)) {
     if (handle) {
       DCHECK_NE(base::kInvalidPlatformFileValue, *handle);
       base::ClosePlatformFile(*handle);
     }
-    underlying_file_util_->DeleteFile(context, path);
+    underlying_file_util_->DeleteFile(context, local_path);
     return base::PLATFORM_FILE_ERROR_FAILED;
   }
   UpdatePathQuotaUsage(context, origin_url, type, 1, file_info->name.size());
 
   return base::PLATFORM_FILE_OK;
 }
 
 FilePath ObfuscatedFileSystemFileUtil::GetLocalPath(
     const GURL& origin_url,
     FileSystemType type,
@@ skipping 196 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();
+    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 45 matching lines @@
       return false;
     }
     origin_database_.reset(
         new FileSystemOriginDatabase(
             file_system_directory_.AppendASCII(kOriginDatabaseName)));
   }
   return true;
 }
 
 }  // namespace fileapi