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 <vector>
 
 #include "base/file_util.h"
@@ skipping 646 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,

[ericu, 2011/08/25 18:29:30]

You're assuming that this context will remain valid throughout the lifetime of
the enumerator.  That's not guaranteed anywhere.

I think it's probably true in all cases currently; you should add a comment to
the block above CreateFileEnumerator in file_system_file_util.h about the
usage...it won't /guarantee/ that nobody deletes the context, but it may make
debugging easier if they do.

[tzik, 2011/08/26 02:41:53]

Make sense. I added a comment there.

+      FileSystemFileUtil* underlying_file_util,
+      const FilePath& virtual_root_path)
+      : base_path_(base_path),
+        db_(db),
+        context_(context),
+        underlying_file_util_(underlying_file_util) {

[kinuko, 2011/08/25 09:28:49]

DCHECK() for pointers? (db, context, underlying_fu)

[tzik, 2011/08/26 02:41:53]

Done.

     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;
+    FileSystemOperationContext context(*context_);

[ericu, 2011/08/25 18:29:30]

There's no need to copy the context here; just pass in context_.

[tzik, 2011/08/26 02:41:53]

I see. Done.

+
+    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