Picasa import: Make NativeMediaFileUtil an AsyncFileUtil

chrome/browser/media_galleries/fileapi/picasa/picasa_file_util_unittest.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 <set>
 #include <string>
 
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop.h"
 #include "base/stringprintf.h"
 #include "base/time.h"
+#include "chrome/browser/media_galleries/fileapi/async_file_util_test_helper.h"
 #include "chrome/browser/media_galleries/fileapi/media_file_system_mount_point_provider.h"
 #include "chrome/browser/media_galleries/fileapi/media_path_filter.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/fileapi/picasa/picasa_file_util.h"
 #include "chrome/browser/media_galleries/fileapi/picasa/pmp_constants.h"
 #include "chrome/browser/media_galleries/fileapi/picasa/pmp_test_helper.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/browser/fileapi/async_file_util_adapter.h"
 #include "webkit/browser/fileapi/external_mount_points.h"
@@ skipping 115 matching lines @@
   }
 
   scoped_ptr<PicasaDataProvider> data_provider_;
 };
 
 class TestMediaFileSystemMountPointProvider
     : public chrome::MediaFileSystemMountPointProvider {
  public:
   TestMediaFileSystemMountPointProvider(
       const base::FilePath& profile_path,
-      scoped_ptr<PicasaFileUtil> picasa_file_util)
+      PicasaFileUtil* picasa_file_util)
       : chrome::MediaFileSystemMountPointProvider(profile_path),
-        test_file_util_(new fileapi::AsyncFileUtilAdapter(
-            picasa_file_util.release())) {
+        test_file_util_(picasa_file_util) {
   }
 
   virtual fileapi::AsyncFileUtil*
   GetAsyncFileUtil(fileapi::FileSystemType type) OVERRIDE {
     if (type != fileapi::kFileSystemTypePicasa)
       return NULL;
 
     return test_file_util_.get();
   }
 
@@ skipping 16 matching lines @@
  public:
   PicasaFileUtilTest() {}
   virtual ~PicasaFileUtilTest() {}
 
   virtual void SetUp() OVERRIDE {
     test_helper_.reset(new PmpTestHelper(kPicasaAlbumTableName));
     ASSERT_TRUE(test_helper_->Init());
 
     scoped_ptr<PicasaDataProvider> data_provider(
         new PicasaDataProvider(test_helper_->GetTempDirPath()));
-    scoped_ptr<PicasaFileUtil> file_util(new TestPicasaFileUtil(
-        data_provider.Pass()));
 
     ASSERT_TRUE(profile_dir_.CreateUniqueTempDir());
 
     scoped_refptr<quota::SpecialStoragePolicy> storage_policy =
         new quota::MockSpecialStoragePolicy();
 
     ScopedVector<fileapi::FileSystemMountPointProvider> additional_providers;
-    additional_providers.push_back(
-        new TestMediaFileSystemMountPointProvider(profile_dir_.path(),
-                                                  file_util.Pass()));
+    additional_providers.push_back(new TestMediaFileSystemMountPointProvider(
+        profile_dir_.path(),
+        new TestPicasaFileUtil(data_provider.Pass())));
 
     file_system_context_ = new fileapi::FileSystemContext(
         fileapi::FileSystemTaskRunners::CreateMockTaskRunners(),
         fileapi::ExternalMountPoints::CreateRefCounted().get(),
         storage_policy,
         NULL,
         additional_providers.Pass(),
         profile_dir_.path(),
         fileapi::CreateAllowFileAccessOptions());
   }
@@ skipping 169 matching lines @@
 
   scoped_ptr<chrome::MediaPathFilter> media_path_filter(
       new chrome::MediaPathFilter());
 
   operation_context->SetUserValue(
       chrome::MediaFileSystemMountPointProvider::kMediaPathFilterKey,
       media_path_filter.get());
 
   scoped_ptr<PicasaDataProvider> data_provider(
       new TestPicasaDataProvider(std::vector<AlbumInfo>(), folders));
-  TestPicasaFileUtil file_util(data_provider.Pass());
+  chrome::AsyncFileUtilTestHelper test_file_util(
+      new TestPicasaFileUtil(data_provider.Pass()));
 
-  scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator> file_enumerator =
-      file_util.CreateFileEnumerator(operation_context.get(),
-                                     CreateURL("folders"));
+  fileapi::AsyncFileUtil::EntryList file_list;
+  bool has_more = false;
+  base::PlatformFileError error = test_file_util.ReadDirectorySync(
+      operation_context.get(),
+      CreateURL(kPicasaDirFolders),
+      &file_list,
+      &has_more);
+  ASSERT_EQ(error, base::PLATFORM_FILE_OK);
 
-  for (unsigned int i = 0; i < expected_names.size(); ++i) {
-    base::FilePath path = file_enumerator->Next();
-
-    ASSERT_TRUE(!path.empty());
-    EXPECT_EQ(expected_names[i], path.BaseName().AsUTF8Unsafe());
-    EXPECT_EQ(folders[i].timestamp, file_enumerator->LastModifiedTime());
-    EXPECT_TRUE(file_enumerator->IsDirectory());
+  for (size_t i = 0; i < file_list.size(); ++i) {
+    ASSERT_FALSE(file_list[i].name.empty());
+    EXPECT_EQ(expected_names[i],
+              base::FilePath(file_list[i].name).AsUTF8Unsafe());
+    EXPECT_EQ(folders[i].timestamp, file_list[i].last_modified_time);
+    EXPECT_TRUE(file_list[i].is_directory);
   }
 }
 
 TEST_F(PicasaFileUtilTest, RootFolders) {
   FileSystemOperation::FileEntryList contents;
   FileSystemURL url = CreateURL("");
   bool completed = false;
   NewOperation(url)->ReadDirectory(
       url, base::Bind(&DidReadDirectory, &contents, &completed));
   base::MessageLoop::current()->RunUntilIdle();
@@ skipping 61 matching lines @@
         new TestFolder(base::StringPrintf("folder-%05d", i),
                        date,
                        base::StringPrintf("uid%05d", i), i % 5, i % 3));
   }
 
   SetupFolders(&test_folders);
   VerifyFolderDirectoryList(test_folders);
 }
 
 }  // namespace chrome