Picasa import: Make NativeMediaFileUtil an AsyncFileUtil

chrome/browser/media_galleries/fileapi/picasa/picasa_file_util.cc

 // Copyright 2013 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 "chrome/browser/media_galleries/fileapi/picasa/picasa_file_util.h"
 
 #include "base/basictypes.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
-#include "chrome/browser/media_galleries/fileapi/filtering_file_enumerator.h"
 #include "chrome/browser/media_galleries/fileapi/media_file_system_mount_point_provider.h"
 #include "chrome/browser/media_galleries/fileapi/picasa/picasa_album_table_reader.h"
 #include "chrome/browser/media_galleries/fileapi/picasa/picasa_data_provider.h"
 #include "chrome/browser/media_galleries/imported_media_gallery_registry.h"
 #include "webkit/browser/fileapi/file_system_operation_context.h"
 #include "webkit/browser/fileapi/file_system_url.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
 using base::FilePath;
 using fileapi::FileSystemOperationContext;
 using fileapi::FileSystemURL;
 
 namespace picasa {
 
 namespace {
 
-class DirectorySkippingFileEnumerator
-    : public fileapi::FileSystemFileUtil::AbstractFileEnumerator {
- public:
-  DirectorySkippingFileEnumerator(
-      scoped_ptr<fileapi::FileSystemFileUtil::AbstractFileEnumerator>
-          base_enumerator)
-      : base_enumerator_(base_enumerator.Pass()) {
-  }
-  virtual ~DirectorySkippingFileEnumerator() {}
-
-  virtual base::FilePath Next() OVERRIDE {
-    while (true) {
-      base::FilePath next = base_enumerator_->Next();
-      if (next.empty() || !base_enumerator_->IsDirectory())
-        return next;
-    }
-  }
-
-  virtual int64 Size() OVERRIDE {
-    return base_enumerator_->Size();
-  }
-
-  virtual base::Time LastModifiedTime() OVERRIDE {
-    return base_enumerator_->LastModifiedTime();
-  }
-
-  virtual bool IsDirectory() OVERRIDE {
-    DCHECK(!base_enumerator_->IsDirectory());
-    return base_enumerator_->IsDirectory();
-  }
-
- private:
-  // The file enumerator to be wrapped.
-  scoped_ptr<fileapi::FileSystemFileUtil::AbstractFileEnumerator>
-      base_enumerator_;
-};
-
-struct VirtualFile {
-  VirtualFile(const base::FilePath& path, int64 size,
-              const base::Time& last_modified_time, bool is_directory)
-      : path(path),
-        size(size),
-        last_modified_time(last_modified_time),
-        is_directory(is_directory) {}
-
-  base::FilePath path;
-  int64 size;
-  base::Time last_modified_time;
-  bool is_directory;
-};
-
-class VirtualFileEnumerator
-    : public fileapi::FileSystemFileUtil::AbstractFileEnumerator {
- public:
-  explicit VirtualFileEnumerator(const std::vector<VirtualFile>& files)
-      : files_(files), next_called_(false), index_(0) {}
-
-  virtual base::FilePath Next() OVERRIDE {
-    if (next_called_ && index_ < files_.size())
-      ++index_;
-
-    next_called_ = true;
-
-    if (index_ >= files_.size())
-      return FilePath();
-    return files_[index_].path;
-  }
-
-  virtual int64 Size() OVERRIDE {
-    if (index_ >= files_.size())
-      return 0;
-    return files_[index_].size;
-  }
-
-  virtual base::Time LastModifiedTime() OVERRIDE {
-    if (index_ >= files_.size())
-      return base::Time();
-    return files_[index_].last_modified_time;
-  }
-
-  virtual bool IsDirectory() OVERRIDE {
-    if (index_ >= files_.size())
-      return false;
-    return files_[index_].is_directory;
-  }
-
- private:
-  std::vector<VirtualFile> files_;
-  bool next_called_;
-  size_t index_;
-};
+fileapi::DirectoryEntry MakeDirectoryEntry(
+    const base::FilePath& path,
+    int64 size,
+    const base::Time& last_modified_time,
+    bool is_directory) {
+  fileapi::DirectoryEntry entry;
+  entry.name = path.BaseName().value();
+  entry.is_directory = is_directory;
+  entry.size = size;
+  entry.last_modified_time = last_modified_time;
+  return entry;
+}
 
 // |error| is only set when the method fails and the return is NULL.
 base::PlatformFileError FindAlbumInfo(const std::string& key,
                                       const AlbumMap* map,
                                       AlbumInfo* album_info) {
   if (!map)
     return base::PLATFORM_FILE_ERROR_FAILED;
 
   AlbumMap::const_iterator it = map->find(key);
 
@@ skipping 36 matching lines @@
 
 }  // namespace
 
 const char kPicasaDirAlbums[]  = "albums";
 const char kPicasaDirFolders[] = "folders";
 
 PicasaFileUtil::PicasaFileUtil() {}
 
 PicasaFileUtil::~PicasaFileUtil() {}
 
-base::PlatformFileError PicasaFileUtil::GetFileInfo(
+base::PlatformFileError PicasaFileUtil::GetFileInfoSync(
     FileSystemOperationContext* context, const FileSystemURL& url,
     base::PlatformFileInfo* file_info, base::FilePath* platform_path) {
   DCHECK(context);
   DCHECK(file_info);
   DCHECK(platform_path);
 
   *platform_path = base::FilePath();
 
   std::vector<std::string> path_components = GetComponents(url);
 
@@ skipping 16 matching lines @@
         base::PlatformFileError error =
             FindAlbumInfo(path_components[1], album_map.get(), NULL);
         if (error != base::PLATFORM_FILE_OK)
           return error;
 
         file_info->is_directory = true;
         return base::PLATFORM_FILE_OK;
       }
 
       if (path_components[0] == kPicasaDirFolders) {
-        return NativeMediaFileUtil::GetFileInfo(context, url, file_info,
-                                                platform_path);
+        return NativeMediaFileUtil::GetFileInfoSync(context, url, file_info,
+                                                    platform_path);
       }
       break;
     case 3:
       // NativeMediaFileUtil::GetInfo calls into virtual function
       // PicasaFileUtil::GetLocalFilePath, and that will handle both
       // album contents and folder contents.
-      base::PlatformFileError result = NativeMediaFileUtil::GetFileInfo(
+      base::PlatformFileError result = NativeMediaFileUtil::GetFileInfoSync(
           context, url, file_info, platform_path);
 
       DCHECK(path_components[0] == kPicasaDirAlbums ||
              path_components[0] == kPicasaDirFolders ||
              result == base::PLATFORM_FILE_ERROR_NOT_FOUND);
 
       return result;
   }
 
   return base::PLATFORM_FILE_ERROR_NOT_FOUND;
 }
 
-scoped_ptr<fileapi::FileSystemFileUtil::AbstractFileEnumerator>
-PicasaFileUtil::CreateFileEnumerator(FileSystemOperationContext* context,
-                                     const FileSystemURL& url) {
+base::PlatformFileError PicasaFileUtil::ReadDirectorySync(
+    fileapi::FileSystemOperationContext* context,
+    const fileapi::FileSystemURL& url,
+    EntryList* file_list) {
   DCHECK(context);
+  DCHECK(file_list);
+  DCHECK(file_list->empty());
+
+  base::PlatformFileInfo file_info;
+  base::FilePath platform_directory_path;
+  base::PlatformFileError error = GetFileInfoSync(
+      context, url, &file_info, &platform_directory_path);
+
+  if (error == base::PLATFORM_FILE_OK && !file_info.is_directory)
+    return base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY;
+
+  if (error != base::PLATFORM_FILE_OK)
+    return error;
+
   std::vector<std::string> path_components = GetComponents(url);
 
-  std::vector<VirtualFile> files;
   FilePath folders_path = base::FilePath().AppendASCII(kPicasaDirFolders);
 
   switch (path_components.size()) {
     case 0: {
       // Root directory.
       FilePath albums_path = base::FilePath().AppendASCII(kPicasaDirAlbums);
-      files.push_back(VirtualFile(albums_path, 0, base::Time(), true));
-      files.push_back(VirtualFile(folders_path, 0, base::Time(), true));
+      file_list->push_back(
+          MakeDirectoryEntry(albums_path, 0, base::Time(), true));
+      file_list->push_back(
+          MakeDirectoryEntry(folders_path, 0, base::Time(), true));
       break;
     }
     case 1:
       if (path_components[0] == kPicasaDirAlbums) {
         scoped_ptr<AlbumMap> albums = DataProvider()->GetAlbums();
         if (!albums)
-          return scoped_ptr<AbstractFileEnumerator>(new EmptyFileEnumerator());
+          return base::PLATFORM_FILE_ERROR_NOT_FOUND;
 
-        // TODO(tommycli): Use AlbumMap enumerator to avoid copies.
         for (AlbumMap::const_iterator it = albums->begin();
              it != albums->end(); ++it) {
-          files.push_back(VirtualFile(
+          file_list->push_back(MakeDirectoryEntry(
               folders_path.Append(FilePath::FromUTF8Unsafe(it->first)),
               0,
               it->second.timestamp,
               true));
         }
       } else if (path_components[0] == kPicasaDirFolders) {
         scoped_ptr<AlbumMap> folders = DataProvider()->GetFolders();
         if (!folders)
-          return scoped_ptr<AbstractFileEnumerator>(new EmptyFileEnumerator());
+          return base::PLATFORM_FILE_ERROR_NOT_FOUND;
 
-        // TODO(tommycli): Use AlbumMap enumerator to avoid copies.
         for (AlbumMap::const_iterator it = folders->begin();
              it != folders->end(); ++it) {
-          files.push_back(VirtualFile(
+          file_list->push_back(MakeDirectoryEntry(
               folders_path.Append(FilePath::FromUTF8Unsafe(it->first)),
               0,
               it->second.timestamp,
               true));
         }
       }
       break;
     case 2:
       if (path_components[0] == kPicasaDirAlbums) {
         // TODO(tommycli): Implement album contents.
       }
 
-      if (path_components[0] == kPicasaDirFolders)
-        return scoped_ptr<AbstractFileEnumerator>(
-            new DirectorySkippingFileEnumerator(
-                NativeMediaFileUtil::CreateFileEnumerator(context, url)));
+      if (path_components[0] == kPicasaDirFolders) {
+        EntryList super_list;
+        base::PlatformFileError error =
+            NativeMediaFileUtil::ReadDirectorySync(context, url, &super_list);
+        if (error != base::PLATFORM_FILE_OK)
+          return error;
+
+        for (EntryList::const_iterator it = super_list.begin();
+             it != super_list.end(); ++it) {
+          if (!it->is_directory)
+            file_list->push_back(*it);
+        }
+      }
+
       break;
   }
 
-  return scoped_ptr<AbstractFileEnumerator>(new VirtualFileEnumerator(files));
+  return base::PLATFORM_FILE_OK;
 }
 
 base::PlatformFileError PicasaFileUtil::GetLocalFilePath(
     FileSystemOperationContext* context, const FileSystemURL& url,
     base::FilePath* local_file_path) {
   DCHECK(local_file_path);
   DCHECK(url.is_valid());
   std::vector<std::string> path_components = GetComponents(url);
 
   switch (path_components.size()) {
@@ skipping 43 matching lines @@
   // intercepted by GetFileInfo()/CreateFileEnumerator(). Invalid cases
   // return a NOT_FOUND error.
   return base::PLATFORM_FILE_ERROR_NOT_FOUND;
 }
 
 PicasaDataProvider* PicasaFileUtil::DataProvider() {
   return chrome::ImportedMediaGalleryRegistry::picasa_data_provider();
 }
 
 }  // namespace picasa