Move Media Galleries FileAPI code out of webkit.

chrome/browser/media_galleries/fileapi/native_media_file_util_unittest.cc

 // Copyright (c) 2012 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/bind.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/format_macros.h"
 #include "base/message_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/native_media_file_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/fileapi/external_mount_points.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_mount_point_provider.h"
 #include "webkit/fileapi/file_system_operation.h"
 #include "webkit/fileapi/file_system_task_runners.h"
 #include "webkit/fileapi/file_system_url.h"
 #include "webkit/fileapi/isolated_context.h"
-#include "webkit/fileapi/media/native_media_file_util.h"
 #include "webkit/fileapi/mock_file_system_options.h"
 #include "webkit/fileapi/native_file_util.h"
 #include "webkit/quota/mock_special_storage_policy.h"
 
 #define FPL(x) FILE_PATH_LITERAL(x)
 
-namespace fileapi {
+using fileapi::FileSystemOperation;
+using fileapi::FileSystemURL;
+
+namespace chrome {
 
 namespace {
 
 typedef FileSystemOperation::FileEntryList FileEntryList;
 
 struct FilteringTestCase {
   const base::FilePath::CharType* path;
   bool is_directory;
   bool visible;
 };
@@ skipping 44 matching lines @@
 void PopulateDirectoryWithTestCases(const base::FilePath& dir,
                                     const FilteringTestCase* test_cases,
                                     size_t n) {
   for (size_t i = 0; i < n; ++i) {
     base::FilePath path = dir.Append(test_cases[i].path);
     if (test_cases[i].is_directory) {
       ASSERT_TRUE(file_util::CreateDirectory(path));
     } else {
       bool created = false;
       ASSERT_EQ(base::PLATFORM_FILE_OK,
-                NativeFileUtil::EnsureFileExists(path, &created));
+                fileapi::NativeFileUtil::EnsureFileExists(path, &created));
       ASSERT_TRUE(created);
     }
   }
 }
 
 }  // namespace
 
 class NativeMediaFileUtilTest : public testing::Test {
  public:
   NativeMediaFileUtilTest()
       : file_util_(NULL) {
   }
 
   virtual void SetUp() {
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
     ASSERT_TRUE(file_util::CreateDirectory(root_path()));
 
     scoped_refptr<quota::SpecialStoragePolicy> storage_policy =
         new quota::MockSpecialStoragePolicy();
 
+    ScopedVector<fileapi::FileSystemMountPointProvider> additional_providers;
+    additional_providers.push_back(new MediaFileSystemMountPointProvider(
+        data_dir_.path()));
+
     file_system_context_ =
-        new FileSystemContext(
-            FileSystemTaskRunners::CreateMockTaskRunners(),
-            ExternalMountPoints::CreateRefCounted().get(),
+        new fileapi::FileSystemContext(
+            fileapi::FileSystemTaskRunners::CreateMockTaskRunners(),
+            fileapi::ExternalMountPoints::CreateRefCounted().get(),
             storage_policy,
             NULL,
-            ScopedVector<FileSystemMountPointProvider>(),
+            additional_providers.Pass(),
             data_dir_.path(),
-            CreateAllowFileAccessOptions());
+            fileapi::CreateAllowFileAccessOptions());
 
-    file_util_ = file_system_context_->GetFileUtil(kFileSystemTypeNativeMedia);
+    file_util_ = file_system_context_->GetFileUtil(
+        fileapi::kFileSystemTypeNativeMedia);
 
     filesystem_id_ = isolated_context()->RegisterFileSystemForPath(
-        kFileSystemTypeNativeMedia, root_path(), NULL);
+        fileapi::kFileSystemTypeNativeMedia, root_path(), NULL);
 
     isolated_context()->AddReference(filesystem_id_);
   }
 
   virtual void TearDown() {
     isolated_context()->RemoveReference(filesystem_id_);
     file_system_context_ = NULL;
   }
 
  protected:
-  FileSystemContext* file_system_context() {
+  fileapi::FileSystemContext* file_system_context() {
     return file_system_context_.get();
   }
 
   FileSystemURL CreateURL(const base::FilePath::CharType* test_case_path) {
     return file_system_context_->CreateCrackedFileSystemURL(
         origin(),
         fileapi::kFileSystemTypeIsolated,
         GetVirtualPath(test_case_path));
   }
 
-  IsolatedContext* isolated_context() {
-    return IsolatedContext::GetInstance();
+  fileapi::IsolatedContext* isolated_context() {
+    return fileapi::IsolatedContext::GetInstance();
   }
 
   base::FilePath root_path() {
     return data_dir_.path().Append(FPL("Media Directory"));
   }
 
-  base::FilePath GetVirtualPath(const base::FilePath::CharType* test_case_path) {
+  base::FilePath GetVirtualPath(
+      const base::FilePath::CharType* test_case_path) {
     return base::FilePath::FromUTF8Unsafe(filesystem_id_).
                Append(FPL("Media Directory")).
                Append(base::FilePath(test_case_path));
   }
 
-  FileSystemFileUtil* file_util() {
+  fileapi::FileSystemFileUtil* file_util() {
     return file_util_;
   }
 
   GURL origin() {
     return GURL("http://example.com");
   }
 
   fileapi::FileSystemType type() {
-    return kFileSystemTypeNativeMedia;
+    return fileapi::kFileSystemTypeNativeMedia;
   }
 
   FileSystemOperation* NewOperation(const FileSystemURL& url) {
     return file_system_context_->CreateFileSystemOperation(url, NULL);
   }
 
  private:
   MessageLoop message_loop_;
 
   base::ScopedTempDir data_dir_;
-  scoped_refptr<FileSystemContext> file_system_context_;
+  scoped_refptr<fileapi::FileSystemContext> file_system_context_;
 
-  FileSystemFileUtil* file_util_;
+  fileapi::FileSystemFileUtil* file_util_;
   std::string filesystem_id_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeMediaFileUtilTest);
 };
 
 TEST_F(NativeMediaFileUtilTest, DirectoryExistsAndFileExistsFiltering) {
   PopulateDirectoryWithTestCases(root_path(),
                                  kFilteringTestCases,
                                  arraysize(kFilteringTestCases));
 
@@ skipping 29 matching lines @@
   bool completed = false;
   NewOperation(url)->ReadDirectory(
       url, base::Bind(&DidReadDirectory, &content, &completed));
   MessageLoop::current()->RunUntilIdle();
   EXPECT_TRUE(completed);
   EXPECT_EQ(5u, content.size());
 
   for (size_t i = 0; i < arraysize(kFilteringTestCases); ++i) {
     base::FilePath::StringType name =
         base::FilePath(kFilteringTestCases[i].path).BaseName().value();
-    std::set<base::FilePath::StringType>::const_iterator found = content.find(name);
+    std::set<base::FilePath::StringType>::const_iterator found =
+        content.find(name);
     EXPECT_EQ(kFilteringTestCases[i].visible, found != content.end());
   }
 }
 
 TEST_F(NativeMediaFileUtilTest, CreateFileAndCreateDirectoryFiltering) {
   // Run the loop twice. The second loop attempts to create files that are
   // pre-existing. Though the result should be the same.
   for (int loop_count = 0; loop_count < 2; ++loop_count) {
     for (size_t i = 0; i < arraysize(kFilteringTestCases); ++i) {
       FileSystemURL root_url = CreateURL(FPL(""));
@@ skipping 346 matching lines @@
         // Files do not exists. Touch fails.
         expectation = base::PLATFORM_FILE_ERROR_FAILED;
       }
       operation->TouchFile(
           url, time, time, base::Bind(&ExpectEqHelper, test_name, expectation));
       MessageLoop::current()->RunUntilIdle();
     }
   }
 }
 
-}  // namespace fileapi
+}  // namespace chrome