Update mtime of directory when containee changed.

webkit/fileapi/obfuscated_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_util.h"
 
 #include <queue>
 #include <string>
 #include <vector>
 
@@ skipping 74 matching lines @@
   int64 growth = GetPathQuotaUsage(growth_in_number_of_paths,
       growth_in_bytes_of_path_length);
   fileapi::FileSystemQuotaUtil* quota_util =
       context->file_system_context()->GetQuotaUtil(type);
   quota::QuotaManagerProxy* quota_manager_proxy =
       context->file_system_context()->quota_manager_proxy();
   quota_util->UpdateOriginUsageOnFileThread(quota_manager_proxy, origin_url,
       type, growth);
 }
 
+void TouchDirectory(fileapi::FileSystemDirectoryDatabase* db,
+                    fileapi::FileSystemDirectoryDatabase::FileId dir_id) {
+  DCHECK(db);
+  // Do nothing for root directory.
+  if (dir_id && !db->UpdateModificationTime(dir_id, base::Time::Now()))
+    NOTREACHED();
+}
+
 const FilePath::CharType kLegacyDataDirectory[] = FILE_PATH_LITERAL("Legacy");
 
 const FilePath::CharType kTemporaryDirectoryName[] = FILE_PATH_LITERAL("t");
 const FilePath::CharType kPersistentDirectoryName[] = FILE_PATH_LITERAL("p");
 
 }  // namespace
 
 namespace fileapi {
 
 using base::PlatformFile;
@@ skipping 279 matching lines @@
   size_t index;
   for (index = 0; index < components.size(); ++index) {
     FilePath::StringType name = components[index];
     if (name == FILE_PATH_LITERAL("/"))
       continue;
     if (!db->GetChildWithName(parent_id, name, &parent_id))
       break;
   }
   if (!recursive && components.size() - index > 1)
     return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+  bool first = true;
   for (; index < components.size(); ++index) {
     FileInfo file_info;
     file_info.name = components[index];
     if (file_info.name == FILE_PATH_LITERAL("/"))
       continue;
     file_info.modification_time = base::Time::Now();
     file_info.parent_id = parent_id;
     if (!AllocateQuotaForPath(context, 1, file_info.name.size()))
       return base::PLATFORM_FILE_ERROR_NO_SPACE;
     if (!db->AddFileInfo(file_info, &parent_id)) {
       NOTREACHED();
       return base::PLATFORM_FILE_ERROR_FAILED;
     }
     UpdatePathQuotaUsage(context, context->src_origin_url(),
       context->src_type(), 1, file_info.name.size());
+    if (first) {
+      first = false;
+      TouchDirectory(db, file_info.parent_id);
+    }
   }
   return base::PLATFORM_FILE_OK;
 }
 
 PlatformFileError ObfuscatedFileUtil::GetFileInfo(
     FileSystemOperationContext* context,
     const FilePath& virtual_path,
     base::PlatformFileInfo* file_info,
     FilePath* platform_file_path) {
   FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
@@ skipping 107 matching lines @@
   FileId file_id;
   if (!db->GetFileWithPath(virtual_path, &file_id))
     return base::PLATFORM_FILE_ERROR_NOT_FOUND;
 
   FileInfo file_info;
   if (!db->GetFileInfo(file_id, &file_info)) {
     NOTREACHED();
     return base::PLATFORM_FILE_ERROR_FAILED;
   }
   if (file_info.is_directory()) {
-    file_info.modification_time = last_modified_time;
-    if (!db->UpdateFileInfo(file_id, file_info))

[tzik, 2011/12/01 16:28:46]

Calling UpdateFileInfo failed for updating directory with children.

+    if (!db->UpdateModificationTime(file_id, last_modified_time))
       return base::PLATFORM_FILE_ERROR_FAILED;
     return base::PLATFORM_FILE_OK;
   }
   FilePath data_path = DataPathToLocalPath(context->src_origin_url(),
     context->src_type(), file_info.data_path);
   return underlying_file_util()->Touch(
       context, data_path, last_access_time, last_modified_time);
 }
 
 PlatformFileError ObfuscatedFileUtil::Truncate(
@@ skipping 127 matching lines @@
       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,
+      PlatformFileError error = underlying_file_util()->CopyOrMoveFile(context,
           src_data_path, dest_data_path, copy);
+      if (error == base::PLATFORM_FILE_OK)
+        TouchDirectory(db, dest_file_info.parent_id);
+      return error;
     } 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;
       }
       InitFileInfo(&dest_file_info, dest_parent_id,
           dest_file_path.BaseName().value());
       if (!AllocateQuotaForPath(context, 1, dest_file_info.name.size()))
         return base::PLATFORM_FILE_ERROR_NO_SPACE;
       return CreateFile(context, context->dest_origin_url(),
           context->dest_type(), src_data_path, &dest_file_info, 0,
           NULL);
     }
   } else {  // It's a move.
     if (overwrite) {
       AllocateQuotaForPath(context, -1,
           -static_cast<int64>(src_file_info.name.size()));
       if (!db->OverwritingMoveFile(src_file_id, dest_file_id))
         return base::PLATFORM_FILE_ERROR_FAILED;
       FilePath dest_data_path = DataPathToLocalPath(context->src_origin_url(),
         context->src_type(), dest_file_info.data_path);
       if (base::PLATFORM_FILE_OK !=
           underlying_file_util()->DeleteFile(context, dest_data_path))
         LOG(WARNING) << "Leaked a backing file.";
       UpdatePathQuotaUsage(context, context->src_origin_url(),
           context->src_type(), -1,
           -static_cast<int64>(src_file_info.name.size()));
+      TouchDirectory(db, src_file_info.parent_id);
+      TouchDirectory(db, dest_file_info.parent_id);
       return base::PLATFORM_FILE_OK;
     } else {
       FileId dest_parent_id;
       if (!db->GetFileWithPath(dest_file_path.DirName(), &dest_parent_id)) {
         NOTREACHED();
         return base::PLATFORM_FILE_ERROR_FAILED;
       }
       if (!AllocateQuotaForPath(
           context, 0,
           static_cast<int64>(dest_file_path.BaseName().value().size())
               - static_cast<int64>(src_file_info.name.size())))
         return base::PLATFORM_FILE_ERROR_NO_SPACE;
+      FileId src_parent_id = src_file_info.parent_id;
       src_file_info.parent_id = dest_parent_id;
       src_file_info.name = dest_file_path.BaseName().value();
       if (!db->UpdateFileInfo(src_file_id, src_file_info))
         return base::PLATFORM_FILE_ERROR_FAILED;
       UpdatePathQuotaUsage(
           context, context->src_origin_url(), context->src_type(), 0,
           static_cast<int64>(dest_file_path.BaseName().value().size()) -
               static_cast<int64>(src_file_path.BaseName().value().size()));
+      TouchDirectory(db, src_parent_id);
+      TouchDirectory(db, dest_parent_id);
       return base::PLATFORM_FILE_OK;
     }
   }
   NOTREACHED();
   return base::PLATFORM_FILE_ERROR_FAILED;
 }
 
 PlatformFileError ObfuscatedFileUtil::CopyInForeignFile(
     FileSystemOperationContext* context,
     const FilePath& src_file_path,
@@ skipping 51 matching lines @@
     return base::PLATFORM_FILE_ERROR_FAILED;
   }
   AllocateQuotaForPath(context, -1, -static_cast<int64>(file_info.name.size()));
   UpdatePathQuotaUsage(context, context->src_origin_url(), context->src_type(),
       -1, -static_cast<int64>(file_info.name.size()));
   FilePath data_path = DataPathToLocalPath(context->src_origin_url(),
     context->src_type(), file_info.data_path);
   if (base::PLATFORM_FILE_OK !=
       underlying_file_util()->DeleteFile(context, data_path))
     LOG(WARNING) << "Leaked a backing file.";
+  TouchDirectory(db, file_info.parent_id);
   return base::PLATFORM_FILE_OK;
 }
 
 PlatformFileError ObfuscatedFileUtil::DeleteSingleDirectory(
     FileSystemOperationContext* context,
     const FilePath& virtual_path) {
   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))
     return base::PLATFORM_FILE_ERROR_NOT_FOUND;
   FileInfo file_info;
   if (!db->GetFileInfo(file_id, &file_info) || !file_info.is_directory()) {
     NOTREACHED();
     return base::PLATFORM_FILE_ERROR_FAILED;
   }
   if (!db->RemoveFileInfo(file_id))
     return base::PLATFORM_FILE_ERROR_NOT_EMPTY;
   AllocateQuotaForPath(context, -1, -static_cast<int64>(file_info.name.size()));
   UpdatePathQuotaUsage(context, context->src_origin_url(), context->src_type(),
       -1, -static_cast<int64>(file_info.name.size()));
+  TouchDirectory(db, file_info.parent_id);
   return base::PLATFORM_FILE_OK;
 }
 
 FilePath ObfuscatedFileUtil::GetDirectoryForOriginAndType(
     const GURL& origin, FileSystemType type, bool create) {
   FilePath origin_dir = GetDirectoryForOrigin(origin, create);
   if (origin_dir.empty())
     return FilePath();
   FilePath::StringType type_string = GetDirectoryNameForType(type);
   if (type_string.empty()) {
@@ skipping 271 matching lines @@
   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, local_path);
     return base::PLATFORM_FILE_ERROR_FAILED;
   }
   UpdatePathQuotaUsage(context, origin_url, type, 1, file_info->name.size());
+  TouchDirectory(db, file_info->parent_id);
 
   return base::PLATFORM_FILE_OK;
 }
 
 FilePath ObfuscatedFileUtil::GetLocalPath(
     const GURL& origin_url,
     FileSystemType type,
     const FilePath& virtual_path) {
   FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
       origin_url, type, false);
@@ skipping 116 matching lines @@
       return false;
     }
     origin_database_.reset(
         new FileSystemOriginDatabase(
             file_system_directory_.AppendASCII(kOriginDatabaseName)));
   }
   return true;
 }
 
 }  // namespace fileapi