Adding Size() to AbstractFileEnumerator

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 <string>
 #include <vector>
 
 #include "base/file_util.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/sys_string_conversions.h"
@@ skipping 25 matching lines @@
 bool IsRootDirectory(const FilePath& virtual_path) {
   return (virtual_path.empty() ||
           virtual_path.value() == FILE_PATH_LITERAL("/"));
 }
 
 // Costs computed as per crbug.com/86114, based on the LevelDB implementation of
 // path storage under Linux.  It's not clear if that will differ on Windows, on
 // which FilePath uses wide chars [since they're converted to UTF-8 for storage
 // anyway], but as long as the cost is high enough that one can't cheat on quota
 // by storing data in paths, it doesn't need to be all that accurate.
-const int64 kPathCreationQuotaCost = 146; // Bytes per inode, basically.
-const int64 kPathByteQuotaCost = 2; // Bytes per byte of path length in UTF-8.
+const int64 kPathCreationQuotaCost = 146;  // Bytes per inode, basically.
+const int64 kPathByteQuotaCost = 2;  // Bytes per byte of path length in UTF-8.
 
 int64 GetPathQuotaUsage(
     int growth_in_number_of_paths,
     int64 growth_in_bytes_of_path_length) {
   return growth_in_number_of_paths * kPathCreationQuotaCost +
       growth_in_bytes_of_path_length * kPathByteQuotaCost;
 }
 
 bool AllocateQuotaForPath(
     fileapi::FileSystemOperationContext* context,
     int growth_in_number_of_paths,
     int64 growth_in_bytes_of_path_length) {
   int64 growth = GetPathQuotaUsage(growth_in_number_of_paths,
       growth_in_bytes_of_path_length);
   int64 new_quota = context->allowed_bytes_growth() - growth;
 
   if (growth <= 0 || new_quota >= 0) {
     context->set_allowed_bytes_growth(new_quota);
     return true;
   }
   return false;
 }
 
 void UpdatePathQuotaUsage(
     fileapi::FileSystemOperationContext* context,
     const GURL& origin_url,
     fileapi::FileSystemType type,
-    int growth_in_number_of_paths, // -1, 0, or 1
+    int growth_in_number_of_paths,  // -1, 0, or 1
     int64 growth_in_bytes_of_path_length) {
   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);
 }
@@ skipping 564 matching lines @@
   // TODO(ericu): This could easily be made faster with help from the database.
   if (!db->ListChildren(file_id, &children))
     return true;
   return children.empty();
 }
 
 class ObfuscatedFileSystemFileEnumerator
     : public FileSystemFileUtil::AbstractFileEnumerator {
  public:
   ObfuscatedFileSystemFileEnumerator(
-      FileSystemDirectoryDatabase* db, const FilePath& virtual_root_path)
-      : db_(db) {
+      const FilePath& base_path,
+      FileSystemDirectoryDatabase* db,
+      FileSystemOperationContext* context,
+      FileSystemFileUtil* underlying_file_util,
+      const FilePath& virtual_root_path)
+      : base_path_(base_path),
+        db_(db),
+        context_(context),
+        underlying_file_util_(underlying_file_util) {
+    DCHECK(db);
+    DCHECK(context);
+    DCHECK(underlying_file_util);

[ericu, 2011/08/26 16:38:24]

It's a tiny nit, but I prefer to DCHECK on the members [db_] rather than the
parameters [db], because it ensures that you've remembered to copy them in.  I
don't always remember to do that, of course, so you'll see both in my code ;'>.

[tzik, 2011/08/29 02:33:32]

Done.
But, if we leave db_ (a raw pointer) uninitialized, it will probabily have
random non-zero value and pass the DCHECK test.

+
     FileId file_id;
     FileInfo file_info;
     if (!db_->GetFileWithPath(virtual_root_path, &file_id))
       return;
     if (!db_->GetFileInfo(file_id, &file_info))
       return;
     if (!file_info.is_directory())
       return;
     FileRecord record = { file_id, file_info, virtual_root_path };
     display_queue_.push(record);
     Next();  // Enumerators don't include the directory itself.
   }
 
   ~ObfuscatedFileSystemFileEnumerator() {}
 
-  virtual FilePath Next() {
+  virtual FilePath Next() OVERRIDE {
     ProcessRecurseQueue();
     if (display_queue_.empty())
       return FilePath();
     current_ = display_queue_.front();
     display_queue_.pop();
     if (current_.file_info.is_directory())
       recurse_queue_.push(current_);
     return current_.file_path;
   }
 
-  virtual bool IsDirectory() {
+  virtual int64 Size() OVERRIDE {
+    if (IsDirectory())
+      return 0;
+
+    base::PlatformFileInfo file_info;
+    FilePath platform_file_path;
+
+    FilePath local_path = base_path_.Append(current_.file_info.data_path);
+    base::PlatformFileError error = underlying_file_util_->GetFileInfo(
+        context_, local_path, &file_info, &platform_file_path);
+    if (error != base::PLATFORM_FILE_OK) {
+      LOG(WARNING) << "Lost a backing file.";
+      return 0;
+    }
+    return file_info.size;
+  }
+
+  virtual bool IsDirectory() OVERRIDE {
     return current_.file_info.is_directory();
   }
 
  private:
   typedef FileSystemDirectoryDatabase::FileId FileId;
   typedef FileSystemDirectoryDatabase::FileInfo FileInfo;
 
   struct FileRecord {
     FileId file_id;
     FileInfo file_info;
@@ skipping 15 matching lines @@
           return;
         child.file_path = directory.file_path.Append(child.file_info.name);
         display_queue_.push(child);
       }
     }
   }
 
   std::queue<FileRecord> display_queue_;
   std::queue<FileRecord> recurse_queue_;
   FileRecord current_;
+  FilePath base_path_;
   FileSystemDirectoryDatabase* db_;
+  FileSystemOperationContext* context_;
+  FileSystemFileUtil* underlying_file_util_;
 };
 
 class ObfuscatedFileSystemOriginEnumerator
     : public ObfuscatedFileSystemFileUtil::AbstractOriginEnumerator {
  public:
   typedef FileSystemOriginDatabase::OriginRecord OriginRecord;
   ObfuscatedFileSystemOriginEnumerator(
       FileSystemOriginDatabase* origin_database,
       const FilePath& base_path)
       : base_path_(base_path) {
@@ skipping 44 matching lines @@
 }
 
 FileSystemFileUtil::AbstractFileEnumerator*
 ObfuscatedFileSystemFileUtil::CreateFileEnumerator(
     FileSystemOperationContext* context,
     const FilePath& root_path) {
   FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
       context->src_origin_url(), context->src_type(), false);
   if (!db)
     return new FileSystemFileUtil::EmptyFileEnumerator();
-  return new ObfuscatedFileSystemFileEnumerator(db, root_path);
+  return new ObfuscatedFileSystemFileEnumerator(
+      GetDirectoryForOriginAndType(context->src_origin_url(),
+                                   context->src_type(), false),
+      db,
+      context,
+      underlying_file_util_.get(),
+      root_path);
 }
 
 PlatformFileError ObfuscatedFileSystemFileUtil::GetFileInfoInternal(
     FileSystemDirectoryDatabase* db,
     FileSystemOperationContext* context,
     FileId file_id,
     FileInfo* local_info,
     base::PlatformFileInfo* file_info,
     FilePath* platform_file_path) {
   DCHECK(db);
@@ skipping 370 matching lines @@
       return false;
     }
     origin_database_.reset(
         new FileSystemOriginDatabase(
             file_system_directory_.AppendASCII(kOriginDatabaseName)));
   }
   return true;
 }
 
 }  // namespace fileapi