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/run_loop.h"
 #include "base/stringprintf.h"
 #include "base/time.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 "content/public/test/test_browser_thread.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"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_file_util.h"
 #include "webkit/browser/fileapi/file_system_operation.h"
 #include "webkit/browser/fileapi/file_system_operation_context.h"
 #include "webkit/browser/fileapi/file_system_task_runners.h"
 #include "webkit/browser/fileapi/isolated_context.h"
 #include "webkit/browser/fileapi/local_file_system_operation.h"
@@ skipping 108 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();
   }
 
  private:
   scoped_ptr<fileapi::AsyncFileUtil> test_file_util_;
 };
 
 void DidReadDirectory(FileSystemOperation::FileEntryList* contents,
                       bool* completed, base::PlatformFileError error,
                       const FileSystemOperation::FileEntryList& file_list,
                       bool has_more) {
   DCHECK(!*completed);
   *completed = !has_more && error == base::PLATFORM_FILE_OK;
   *contents = file_list;
 }
 
+void ReadDirectoryTestCallback(
+    base::RunLoop* run_loop,
+    base::PlatformFileError* error_result,
+    fileapi::AsyncFileUtil::EntryList* file_list_result,
+    base::PlatformFileError error,
+    const fileapi::AsyncFileUtil::EntryList& file_list,
+    bool /*has_more*/) {
+  DCHECK(error_result);
+  DCHECK(file_list_result);
+  *error_result = error;
+  *file_list_result = file_list;
+  run_loop->Quit();
+}
+
+base::PlatformFileError ReadDirectoryTestHelper(
+    fileapi::AsyncFileUtil* file_util,
+    FileSystemOperationContext* operation_context,
+    FileSystemURL url,
+    fileapi::AsyncFileUtil::EntryList* file_list) {
+  base::RunLoop run_loop;
+  base::PlatformFileError result;
+  file_util->ReadDirectory(
+      operation_context,
+      url,
+      base::Bind(&ReadDirectoryTestCallback, &run_loop, &result, file_list));
+  run_loop.Run();
+  return result;
+}
+
 }  // namespace
 
 class PicasaFileUtilTest : public testing::Test {
  public:
-  PicasaFileUtilTest() {}
+  PicasaFileUtilTest()
+      : io_thread_(content::BrowserThread::IO, &message_loop_) {
+  }
   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.get(),
         NULL,
         additional_providers.Pass(),
         profile_dir_.path(),
         fileapi::CreateAllowFileAccessOptions());
   }
@@ skipping 107 matching lines @@
   FileSystemOperation* NewOperation(const FileSystemURL& url) {
     return file_system_context_->CreateFileSystemOperation(url, NULL);
   }
 
   scoped_refptr<fileapi::FileSystemContext> file_system_context() {
     return file_system_context_;
   }
 
  private:
   base::MessageLoop message_loop_;
+  content::TestBrowserThread io_thread_;
 
   base::ScopedTempDir profile_dir_;
 
   scoped_refptr<fileapi::FileSystemContext> file_system_context_;
   scoped_ptr<PmpTestHelper> test_helper_;
 
   DISALLOW_COPY_AND_ASSIGN(PicasaFileUtilTest);
 };
 
 TEST_F(PicasaFileUtilTest, DateFormat) {
@@ skipping 30 matching lines @@
   expected_names.push_back("duplicate " + test_date_string + " (1)");
 
   folders.push_back(
       AlbumInfo("duplicate", test_date, "uuid5", base::FilePath()));
   expected_names.push_back("duplicate " + test_date_string + " (2)");
 
   folders.push_back(
       AlbumInfo("unique_name", test_date, "uuid1", base::FilePath()));
   expected_names.push_back("unique_name " + test_date_string);
 
-  scoped_ptr<FileSystemOperationContext> operation_context(
-      new FileSystemOperationContext(file_system_context().get()));
+  FileSystemOperationContext operation_context(file_system_context().get());
 
   scoped_ptr<chrome::MediaPathFilter> media_path_filter(
       new chrome::MediaPathFilter());
 
-  operation_context->SetUserValue(
+  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());
+  TestPicasaFileUtil test_file_util(data_provider.Pass());
 
-  scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator> file_enumerator =
-      file_util.CreateFileEnumerator(operation_context.get(),
-                                     CreateURL("folders"));
+  fileapi::AsyncFileUtil::EntryList file_list;
+  ASSERT_EQ(base::PLATFORM_FILE_OK,
+            ReadDirectoryTestHelper(&test_file_util, &operation_context,
+                                    CreateURL(kPicasaDirFolders),
+                                    &file_list));
 
-  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());
+  ASSERT_EQ(expected_names.size(), file_list.size());
+  for (size_t i = 0; i < file_list.size(); ++i) {
+    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