Change fileapi namespace to content for files that are moved under content/

content/browser/fileapi/copy_or_move_operation_delegate_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 <map>
 #include <queue>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/file_util.h"
@@ skipping 11 matching lines @@
 #include "webkit/browser/fileapi/file_stream_writer.h"
 #include "webkit/browser/fileapi/file_system_backend.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_operation.h"
 #include "webkit/browser/fileapi/file_system_url.h"
 #include "webkit/browser/fileapi/test_file_set.h"
 #include "webkit/browser/quota/mock_quota_manager.h"
 #include "webkit/browser/quota/quota_manager.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
-namespace fileapi {
+using fileapi::AsyncFileTestHelper;
+using fileapi::CopyOrMoveOperationDelegate;
+using fileapi::FileStreamWriter;
+using fileapi::FileSystemOperation;
+using fileapi::FileSystemType;
+using fileapi::FileSystemURL;
+using fileapi::test::TestCaseRecord;
 
-typedef FileSystemOperation::FileEntryList FileEntryList;
+namespace content {
+
+typedef fileapi::FileSystemOperation::FileEntryList FileEntryList;
 
 namespace {
 
 void ExpectOk(const GURL& origin_url,
               const std::string& name,
               base::PlatformFileError error) {
   ASSERT_EQ(base::PLATFORM_FILE_OK, error);
 }
 
-class TestValidatorFactory : public CopyOrMoveFileValidatorFactory {
+class TestValidatorFactory : public fileapi::CopyOrMoveFileValidatorFactory {
  public:
   // A factory that creates validators that accept everything or nothing.
   TestValidatorFactory() {}
   virtual ~TestValidatorFactory() {}
 
-  virtual CopyOrMoveFileValidator* CreateCopyOrMoveFileValidator(
+  virtual fileapi::CopyOrMoveFileValidator* CreateCopyOrMoveFileValidator(
       const FileSystemURL& /*src_url*/,
       const base::FilePath& /*platform_path*/) OVERRIDE {
     // Move arg management to TestValidator?
     return new TestValidator(true, true, std::string("2"));
   }
 
  private:
-  class TestValidator : public CopyOrMoveFileValidator {
+  class TestValidator : public fileapi::CopyOrMoveFileValidator {
    public:
     explicit TestValidator(bool pre_copy_valid,
                            bool post_copy_valid,
                            const std::string& reject_string)
         : result_(pre_copy_valid ? base::PLATFORM_FILE_OK
                                  : base::PLATFORM_FILE_ERROR_SECURITY),
           write_result_(post_copy_valid ? base::PLATFORM_FILE_OK
                                         : base::PLATFORM_FILE_ERROR_SECURITY),
           reject_string_(reject_string) {
     }
@@ skipping 23 matching lines @@
     base::PlatformFileError result_;
     base::PlatformFileError write_result_;
     std::string reject_string_;
 
     DISALLOW_COPY_AND_ASSIGN(TestValidator);
   };
 };
 
 // Records CopyProgressCallback invocations.
 struct ProgressRecord {
-  FileSystemOperation::CopyProgressType type;
+  fileapi::FileSystemOperation::CopyProgressType type;
   FileSystemURL source_url;
   FileSystemURL dest_url;
   int64 size;
 };
 
 void RecordProgressCallback(std::vector<ProgressRecord>* records,
-                            FileSystemOperation::CopyProgressType type,
+                            fileapi::FileSystemOperation::CopyProgressType type,
                             const FileSystemURL& source_url,
                             const FileSystemURL& dest_url,
                             int64 size) {
   ProgressRecord record;
   record.type = type;
   record.source_url = source_url;
   record.dest_url = dest_url;
   record.size = size;
   records->push_back(record);
 }
@@ skipping 70 matching lines @@
                                     base_dir,
                                     base::MessageLoopProxy::current().get(),
                                     base::MessageLoopProxy::current().get(),
                                     NULL /* special storage policy */);
     quota_manager_proxy_ = new quota::MockQuotaManagerProxy(
         quota_manager_.get(), base::MessageLoopProxy::current().get());
     file_system_context_ =
         CreateFileSystemContextForTesting(quota_manager_proxy_.get(), base_dir);
 
     // Prepare the origin's root directory.
-    FileSystemBackend* backend =
+    fileapi::FileSystemBackend* backend =
         file_system_context_->GetFileSystemBackend(src_type_);
     backend->OpenFileSystem(origin_, src_type_,
-                            OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
+                            fileapi::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
                             base::Bind(&ExpectOk));
     backend = file_system_context_->GetFileSystemBackend(dest_type_);
-    if (dest_type_ == kFileSystemTypeTest) {
+    if (dest_type_ == fileapi::kFileSystemTypeTest) {
       TestFileSystemBackend* test_backend =
           static_cast<TestFileSystemBackend*>(backend);
-      scoped_ptr<CopyOrMoveFileValidatorFactory> factory(
+      scoped_ptr<fileapi::CopyOrMoveFileValidatorFactory> factory(
           new TestValidatorFactory);
       test_backend->set_require_copy_or_move_validator(
           require_copy_or_move_validator);
       if (init_copy_or_move_validator)
         test_backend->InitializeCopyOrMoveFileValidatorFactory(factory.Pass());
     }
     backend->OpenFileSystem(origin_, dest_type_,
-                            OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
+                            fileapi::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
                             base::Bind(&ExpectOk));
     base::RunLoop().RunUntilIdle();
 
     // Grant relatively big quota initially.
-    quota_manager_->SetQuota(origin_,
-                             FileSystemTypeToQuotaStorageType(src_type_),
-                             1024 * 1024);
-    quota_manager_->SetQuota(origin_,
-                             FileSystemTypeToQuotaStorageType(dest_type_),
-                             1024 * 1024);
+    quota_manager_->SetQuota(
+        origin_,
+        fileapi::FileSystemTypeToQuotaStorageType(src_type_),
+        1024 * 1024);
+    quota_manager_->SetQuota(
+        origin_,
+        fileapi::FileSystemTypeToQuotaStorageType(dest_type_),
+        1024 * 1024);
   }
 
   int64 GetSourceUsage() {
     int64 usage = 0;
     GetUsageAndQuota(src_type_, &usage, NULL);
     return usage;
   }
 
   int64 GetDestUsage() {
     int64 usage = 0;
@@ skipping 24 matching lines @@
         file_system_context_.get(), src, dest, progress_callback);
   }
 
   base::PlatformFileError Move(const FileSystemURL& src,
                                const FileSystemURL& dest) {
     return AsyncFileTestHelper::Move(file_system_context_.get(), src, dest);
   }
 
   base::PlatformFileError SetUpTestCaseFiles(
       const FileSystemURL& root,
-      const test::TestCaseRecord* const test_cases,
+      const TestCaseRecord* const test_cases,
       size_t test_case_size) {
     base::PlatformFileError result = base::PLATFORM_FILE_ERROR_FAILED;
     for (size_t i = 0; i < test_case_size; ++i) {
-      const test::TestCaseRecord& test_case = test_cases[i];
+      const TestCaseRecord& test_case = test_cases[i];
       FileSystemURL url = file_system_context_->CreateCrackedFileSystemURL(
           root.origin(),
           root.mount_type(),
           root.virtual_path().Append(test_case.path));
       if (test_case.is_directory)
         result = CreateDirectory(url);
       else
         result = CreateFile(url, test_case.data_file_size);
       EXPECT_EQ(base::PLATFORM_FILE_OK, result) << url.DebugString();
       if (result != base::PLATFORM_FILE_OK)
         return result;
     }
     return result;
   }
 
   void VerifyTestCaseFiles(
       const FileSystemURL& root,
-      const test::TestCaseRecord* const test_cases,
+      const TestCaseRecord* const test_cases,
       size_t test_case_size) {
-    std::map<base::FilePath, const test::TestCaseRecord*> test_case_map;
+    std::map<base::FilePath, const TestCaseRecord*> test_case_map;
     for (size_t i = 0; i < test_case_size; ++i) {
       test_case_map[
           base::FilePath(test_cases[i].path).NormalizePathSeparators()] =
               &test_cases[i];
     }
 
     std::queue<FileSystemURL> directories;
     FileEntryList entries;
     directories.push(root);
     while (!directories.empty()) {
@@ skipping 13 matching lines @@
           EXPECT_TRUE(test_case_map[relative]->is_directory);
           directories.push(url);
         } else {
           EXPECT_FALSE(test_case_map[relative]->is_directory);
           EXPECT_TRUE(FileExists(url, test_case_map[relative]->data_file_size));
         }
         test_case_map.erase(relative);
       }
     }
     EXPECT_TRUE(test_case_map.empty());
-    std::map<base::FilePath, const test::TestCaseRecord*>::const_iterator it;
+    std::map<base::FilePath, const TestCaseRecord*>::const_iterator it;
     for (it = test_case_map.begin(); it != test_case_map.end(); ++it) {
       LOG(ERROR) << "Extra entry: " << it->first.LossyDisplayName();
     }
   }
 
   base::PlatformFileError ReadDirectory(const FileSystemURL& url,
                                         FileEntryList* entries) {
     return AsyncFileTestHelper::ReadDirectory(
         file_system_context_.get(), url, entries);
   }
@@ skipping 30 matching lines @@
   }
 
  private:
   base::ScopedTempDir base_;
 
   const GURL origin_;
   const FileSystemType src_type_;
   const FileSystemType dest_type_;
 
   base::MessageLoopForIO message_loop_;
-  scoped_refptr<FileSystemContext> file_system_context_;
+  scoped_refptr<fileapi::FileSystemContext> file_system_context_;
   scoped_refptr<quota::MockQuotaManagerProxy> quota_manager_proxy_;
   scoped_refptr<quota::MockQuotaManager> quota_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(CopyOrMoveOperationTestHelper);
 };
 
 TEST(LocalFileSystemCopyOrMoveOperationTest, CopySingleFile) {
   CopyOrMoveOperationTestHelper helper(GURL("http://foo"),
-                                       kFileSystemTypeTemporary,
-                                       kFileSystemTypePersistent);
+                                       fileapi::kFileSystemTypeTemporary,
+                                       fileapi::kFileSystemTypePersistent);
   helper.SetUp();
 
   FileSystemURL src = helper.SourceURL("a");
   FileSystemURL dest = helper.DestURL("b");
   int64 src_initial_usage = helper.GetSourceUsage();
   int64 dest_initial_usage = helper.GetDestUsage();
 
   // Set up a source file.
   ASSERT_EQ(base::PLATFORM_FILE_OK, helper.CreateFile(src, 10));
   int64 src_increase = helper.GetSourceUsage() - src_initial_usage;
 
   // Copy it.
   ASSERT_EQ(base::PLATFORM_FILE_OK, helper.Copy(src, dest));
 
   // Verify.
   ASSERT_TRUE(helper.FileExists(src, 10));
   ASSERT_TRUE(helper.FileExists(dest, 10));
 
   int64 src_new_usage = helper.GetSourceUsage();
   ASSERT_EQ(src_initial_usage + src_increase, src_new_usage);
 
   int64 dest_increase = helper.GetDestUsage() - dest_initial_usage;
   ASSERT_EQ(src_increase, dest_increase);
 }
 
 TEST(LocalFileSystemCopyOrMoveOperationTest, MoveSingleFile) {
   CopyOrMoveOperationTestHelper helper(GURL("http://foo"),
-                                       kFileSystemTypeTemporary,
-                                       kFileSystemTypePersistent);
+                                       fileapi::kFileSystemTypeTemporary,
+                                       fileapi::kFileSystemTypePersistent);
   helper.SetUp();
 
   FileSystemURL src = helper.SourceURL("a");
   FileSystemURL dest = helper.DestURL("b");
   int64 src_initial_usage = helper.GetSourceUsage();
   int64 dest_initial_usage = helper.GetDestUsage();
 
   // Set up a source file.
   ASSERT_EQ(base::PLATFORM_FILE_OK, helper.CreateFile(src, 10));
   int64 src_increase = helper.GetSourceUsage() - src_initial_usage;
 
   // Move it.
   ASSERT_EQ(base::PLATFORM_FILE_OK, helper.Move(src, dest));
 
   // Verify.
   ASSERT_FALSE(helper.FileExists(src, AsyncFileTestHelper::kDontCheckSize));
   ASSERT_TRUE(helper.FileExists(dest, 10));
 
   int64 src_new_usage = helper.GetSourceUsage();
   ASSERT_EQ(src_initial_usage, src_new_usage);
 
   int64 dest_increase = helper.GetDestUsage() - dest_initial_usage;
   ASSERT_EQ(src_increase, dest_increase);
 }
 
 TEST(LocalFileSystemCopyOrMoveOperationTest, CopySingleDirectory) {
   CopyOrMoveOperationTestHelper helper(GURL("http://foo"),
-                                       kFileSystemTypeTemporary,
-                                       kFileSystemTypePersistent);
+                                       fileapi::kFileSystemTypeTemporary,
+                                       fileapi::kFileSystemTypePersistent);
   helper.SetUp();
 
   FileSystemURL src = helper.SourceURL("a");
   FileSystemURL dest = helper.DestURL("b");
   int64 src_initial_usage = helper.GetSourceUsage();
   int64 dest_initial_usage = helper.GetDestUsage();
 
   // Set up a source directory.
   ASSERT_EQ(base::PLATFORM_FILE_OK, helper.CreateDirectory(src));
   int64 src_increase = helper.GetSourceUsage() - src_initial_usage;
 
   // Copy it.
   ASSERT_EQ(base::PLATFORM_FILE_OK, helper.Copy(src, dest));
 
   // Verify.
   ASSERT_TRUE(helper.DirectoryExists(src));
   ASSERT_TRUE(helper.DirectoryExists(dest));
 
   int64 src_new_usage = helper.GetSourceUsage();
   ASSERT_EQ(src_initial_usage + src_increase, src_new_usage);
 
   int64 dest_increase = helper.GetDestUsage() - dest_initial_usage;
   ASSERT_EQ(src_increase, dest_increase);
 }
 
 TEST(LocalFileSystemCopyOrMoveOperationTest, MoveSingleDirectory) {
   CopyOrMoveOperationTestHelper helper(GURL("http://foo"),
-                                       kFileSystemTypeTemporary,
-                                       kFileSystemTypePersistent);
+                                       fileapi::kFileSystemTypeTemporary,
+                                       fileapi::kFileSystemTypePersistent);
   helper.SetUp();
 
   FileSystemURL src = helper.SourceURL("a");
   FileSystemURL dest = helper.DestURL("b");
   int64 src_initial_usage = helper.GetSourceUsage();
   int64 dest_initial_usage = helper.GetDestUsage();
 
   // Set up a source directory.
   ASSERT_EQ(base::PLATFORM_FILE_OK, helper.CreateDirectory(src));
   int64 src_increase = helper.GetSourceUsage() - src_initial_usage;
 
   // Move it.
   ASSERT_EQ(base::PLATFORM_FILE_OK, helper.Move(src, dest));
 
   // Verify.
   ASSERT_FALSE(helper.DirectoryExists(src));
   ASSERT_TRUE(helper.DirectoryExists(dest));
 
   int64 src_new_usage = helper.GetSourceUsage();
   ASSERT_EQ(src_initial_usage, src_new_usage);
 
   int64 dest_increase = helper.GetDestUsage() - dest_initial_usage;
   ASSERT_EQ(src_increase, dest_increase);
 }
 
 TEST(LocalFileSystemCopyOrMoveOperationTest, CopyDirectory) {
   CopyOrMoveOperationTestHelper helper(GURL("http://foo"),
-                                       kFileSystemTypeTemporary,
-                                       kFileSystemTypePersistent);
+                                       fileapi::kFileSystemTypeTemporary,
+                                       fileapi::kFileSystemTypePersistent);
   helper.SetUp();
 
   FileSystemURL src = helper.SourceURL("a");
   FileSystemURL dest = helper.DestURL("b");
   int64 src_initial_usage = helper.GetSourceUsage();
   int64 dest_initial_usage = helper.GetDestUsage();
 
   // Set up a source directory.
   ASSERT_EQ(base::PLATFORM_FILE_OK, helper.CreateDirectory(src));
   ASSERT_EQ(base::PLATFORM_FILE_OK,
             helper.SetUpTestCaseFiles(src,
-                                      test::kRegularTestCases,
-                                      test::kRegularTestCaseSize));
+                                      fileapi::test::kRegularTestCases,
+                                      fileapi::test::kRegularTestCaseSize));
   int64 src_increase = helper.GetSourceUsage() - src_initial_usage;
 
   // Copy it.
   ASSERT_EQ(base::PLATFORM_FILE_OK,
             helper.CopyWithProgress(
                 src, dest,
                 AsyncFileTestHelper::CopyProgressCallback()));
 
   // Verify.
   ASSERT_TRUE(helper.DirectoryExists(src));
   ASSERT_TRUE(helper.DirectoryExists(dest));
 
   helper.VerifyTestCaseFiles(dest,
-                             test::kRegularTestCases,
-                             test::kRegularTestCaseSize);
+                             fileapi::test::kRegularTestCases,
+                             fileapi::test::kRegularTestCaseSize);
 
   int64 src_new_usage = helper.GetSourceUsage();
   ASSERT_EQ(src_initial_usage + src_increase, src_new_usage);
 
   int64 dest_increase = helper.GetDestUsage() - dest_initial_usage;
   ASSERT_EQ(src_increase, dest_increase);
 }
 
 TEST(LocalFileSystemCopyOrMoveOperationTest, MoveDirectory) {
   CopyOrMoveOperationTestHelper helper(GURL("http://foo"),
-                                       kFileSystemTypeTemporary,
-                                       kFileSystemTypePersistent);
+                                       fileapi::kFileSystemTypeTemporary,
+                                       fileapi::kFileSystemTypePersistent);
   helper.SetUp();
 
   FileSystemURL src = helper.SourceURL("a");
   FileSystemURL dest = helper.DestURL("b");
   int64 src_initial_usage = helper.GetSourceUsage();
   int64 dest_initial_usage = helper.GetDestUsage();
 
   // Set up a source directory.
   ASSERT_EQ(base::PLATFORM_FILE_OK, helper.CreateDirectory(src));
   ASSERT_EQ(base::PLATFORM_FILE_OK,
             helper.SetUpTestCaseFiles(src,
-                                      test::kRegularTestCases,
-                                      test::kRegularTestCaseSize));
+                                      fileapi::test::kRegularTestCases,
+                                      fileapi::test::kRegularTestCaseSize));
   int64 src_increase = helper.GetSourceUsage() - src_initial_usage;
 
   // Move it.
   ASSERT_EQ(base::PLATFORM_FILE_OK, helper.Move(src, dest));
 
   // Verify.
   ASSERT_FALSE(helper.DirectoryExists(src));
   ASSERT_TRUE(helper.DirectoryExists(dest));
 
   helper.VerifyTestCaseFiles(dest,
-                             test::kRegularTestCases,
-                             test::kRegularTestCaseSize);
+                             fileapi::test::kRegularTestCases,
+                             fileapi::test::kRegularTestCaseSize);
 
   int64 src_new_usage = helper.GetSourceUsage();
   ASSERT_EQ(src_initial_usage, src_new_usage);
 
   int64 dest_increase = helper.GetDestUsage() - dest_initial_usage;
   ASSERT_EQ(src_increase, dest_increase);
 }
 
 TEST(LocalFileSystemCopyOrMoveOperationTest,
      MoveDirectoryFailPostWriteValidation) {
   CopyOrMoveOperationTestHelper helper(GURL("http://foo"),
-                                       kFileSystemTypeTemporary,
-                                       kFileSystemTypeTest);
+                                       fileapi::kFileSystemTypeTemporary,
+                                       fileapi::kFileSystemTypeTest);
   helper.SetUp();
 
   FileSystemURL src = helper.SourceURL("a");
   FileSystemURL dest = helper.DestURL("b");
 
   // Set up a source directory.
   ASSERT_EQ(base::PLATFORM_FILE_OK, helper.CreateDirectory(src));
   ASSERT_EQ(base::PLATFORM_FILE_OK,
             helper.SetUpTestCaseFiles(src,
-                                      test::kRegularTestCases,
-                                      test::kRegularTestCaseSize));
+                                      fileapi::test::kRegularTestCases,
+                                      fileapi::test::kRegularTestCaseSize));
 
   // Move it.
   helper.Move(src, dest);
 
   // Verify.
   ASSERT_TRUE(helper.DirectoryExists(src));
   ASSERT_TRUE(helper.DirectoryExists(dest));
 
-  test::TestCaseRecord kMoveDirResultCases[] = {
+  TestCaseRecord kMoveDirResultCases[] = {
     {false, FILE_PATH_LITERAL("file 0"), 38},
     {false, FILE_PATH_LITERAL("file 3"), 0},
   };
 
   helper.VerifyTestCaseFiles(dest,
                              kMoveDirResultCases,
                              arraysize(kMoveDirResultCases));
 }
 
 TEST(LocalFileSystemCopyOrMoveOperationTest, CopySingleFileNoValidator) {
   CopyOrMoveOperationTestHelper helper(GURL("http://foo"),
-                                       kFileSystemTypeTemporary,
-                                       kFileSystemTypeTest);
+                                       fileapi::kFileSystemTypeTemporary,
+                                       fileapi::kFileSystemTypeTest);
   helper.SetUpNoValidator();
 
   FileSystemURL src = helper.SourceURL("a");
   FileSystemURL dest = helper.DestURL("b");
 
   // Set up a source file.
   ASSERT_EQ(base::PLATFORM_FILE_OK, helper.CreateFile(src, 10));
 
   // The copy attempt should fail with a security error -- getting
   // the factory returns a security error, and the copy operation must
   // respect that.
   ASSERT_EQ(base::PLATFORM_FILE_ERROR_SECURITY, helper.Copy(src, dest));
 }
 
 TEST(LocalFileSystemCopyOrMoveOperationTest, ProgressCallback) {
   CopyOrMoveOperationTestHelper helper(GURL("http://foo"),
-                                       kFileSystemTypeTemporary,
-                                       kFileSystemTypePersistent);
+                                       fileapi::kFileSystemTypeTemporary,
+                                       fileapi::kFileSystemTypePersistent);
   helper.SetUp();
 
   FileSystemURL src = helper.SourceURL("a");
   FileSystemURL dest = helper.DestURL("b");
 
   // Set up a source directory.
   ASSERT_EQ(base::PLATFORM_FILE_OK, helper.CreateDirectory(src));
   ASSERT_EQ(base::PLATFORM_FILE_OK,
             helper.SetUpTestCaseFiles(src,
-                                      test::kRegularTestCases,
-                                      test::kRegularTestCaseSize));
+                                      fileapi::test::kRegularTestCases,
+                                      fileapi::test::kRegularTestCaseSize));
 
   std::vector<ProgressRecord> records;
   ASSERT_EQ(base::PLATFORM_FILE_OK,
             helper.CopyWithProgress(src, dest,
                                     base::Bind(&RecordProgressCallback,
                                                base::Unretained(&records))));
 
   // Verify progress callback.
-  for (size_t i = 0; i < test::kRegularTestCaseSize; ++i) {
-    const test::TestCaseRecord& test_case = test::kRegularTestCases[i];
+  for (size_t i = 0; i < fileapi::test::kRegularTestCaseSize; ++i) {
+    const TestCaseRecord& test_case = fileapi::test::kRegularTestCases[i];
 
     FileSystemURL src_url = helper.SourceURL(
         std::string("a/") + base::FilePath(test_case.path).AsUTF8Unsafe());
     FileSystemURL dest_url = helper.DestURL(
         std::string("b/") + base::FilePath(test_case.path).AsUTF8Unsafe());
 
     // Find the first and last progress record.
     size_t begin_index = records.size();
     size_t end_index = records.size();
     for (size_t j = 0; j < records.size(); ++j) {
@@ skipping 188 matching lines @@
                  base::Unretained(&helper)));
 
   base::PlatformFileError error = base::PLATFORM_FILE_ERROR_FAILED;
   base::RunLoop run_loop;
   helper.Run(base::Bind(&AssignAndQuit, &run_loop, &error));
   run_loop.Run();
 
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_ABORT, error);
 }
 
-}  // namespace fileapi
+}  // namespace content