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 139 matching lines @@
 
   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(),
     context->src_type(), file_info.data_path);
-  return underlying_file_util_->CreateOrOpen(
+  base::PlatformFileError error = underlying_file_util_->CreateOrOpen(
       context, data_path, file_flags, file_handle, created);
+  if (error == base::PLATFORM_FILE_ERROR_NOT_FOUND) {
+    // 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.";
+    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 460 matching lines @@
   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 */);
     created = true;
   } else {
+    if (file_util::PathExists(path)) {

[ericu, 2011/08/24 03:43:50]

This should probably use underlying_file_util_, not file_util.  However, in the
case of quota_file_util, which is generally what's under there, it might falsely
lower the quota.  Dai, Kinuko: what do you think about this?

[tzik, 2011/08/29 06:54:13]

We use underlying_file_util_ in the next patch.
It makes the usage lower than actual usage until next recalculation, maybe until
next boot.

[kinuko, 2011/08/29 07:45:37]

Maybe we can explicitly call underlying_file_util_->GetLocalFilePath() to get a
platform path and call file_util methods?

[tzik, 2011/08/29 08:34:15]

Done.

[ericu, 2011/08/29 22:48:20]

Thanks, and Kinuko, that was a good idea.
I've just noticed another inconsistency, though, which dates from when I wrote
this.  GetDirectoryForOriginAndType always returns a real OS path, and I've
mixed that in with calls to underlying_file_util as if the paths are in the same
namespace.  I don't see an obvious fix for that right now, but then nothing's
actually broken yet, just brittle.  Taiju, would you mind putting in this
comment for me?

[at line 864] TODO(ericu): local_path is an OS path; underlying_file_util_ isn't
guaranteed to understand OS paths.

Thanks.

[tzik, 2011/08/31 02:40:05]

Done.

+      if (!file_util::Delete(path, false)) {
+        NOTREACHED();
+        return base::PLATFORM_FILE_ERROR_FAILED;
+      }
+      LOG(WARNING) << "A stray file detected";
+    }
+
     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);
     }
   }
@@ skipping 226 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