Collapse fileapi, webkit_blob, webkit_database, quota, and webkit_common namespaces into single sto…

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/file_util.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 11 matching lines @@
 #include "webkit/browser/fileapi/external_mount_points.h"
 #include "webkit/browser/fileapi/file_system_backend.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_operation_runner.h"
 #include "webkit/browser/fileapi/file_system_url.h"
 #include "webkit/browser/fileapi/isolated_context.h"
 #include "webkit/browser/fileapi/native_file_util.h"
 
 #define FPL(x) FILE_PATH_LITERAL(x)
 
-using fileapi::FileSystemOperation;
-using fileapi::FileSystemURL;
+using storage::FileSystemOperation;
+using storage::FileSystemURL;
 
 namespace {
 
 typedef FileSystemOperation::FileEntryList FileEntryList;
 
 struct FilteringTestCase {
   const base::FilePath::CharType* path;
   bool is_directory;
   bool visible;
   bool media_file;
@@ skipping 68 matching lines @@
 class NativeMediaFileUtilTest : public testing::Test {
  public:
   NativeMediaFileUtilTest()
       : io_thread_(content::BrowserThread::IO, &message_loop_) {
   }
 
   virtual void SetUp() {
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
     ASSERT_TRUE(base::CreateDirectory(root_path()));
 
-    scoped_refptr<quota::SpecialStoragePolicy> storage_policy =
+    scoped_refptr<storage::SpecialStoragePolicy> storage_policy =
         new content::MockSpecialStoragePolicy();
 
-    ScopedVector<fileapi::FileSystemBackend> additional_providers;
+    ScopedVector<storage::FileSystemBackend> additional_providers;
     additional_providers.push_back(new MediaFileSystemBackend(
         data_dir_.path(), base::MessageLoopProxy::current().get()));
 
-    file_system_context_ = new fileapi::FileSystemContext(
+    file_system_context_ = new storage::FileSystemContext(
         base::MessageLoopProxy::current().get(),
         base::MessageLoopProxy::current().get(),
-        fileapi::ExternalMountPoints::CreateRefCounted().get(),
+        storage::ExternalMountPoints::CreateRefCounted().get(),
         storage_policy.get(),
         NULL,
         additional_providers.Pass(),
-        std::vector<fileapi::URLRequestAutoMountHandler>(),
+        std::vector<storage::URLRequestAutoMountHandler>(),
         data_dir_.path(),
         content::CreateAllowFileAccessOptions());
 
     filesystem_id_ = isolated_context()->RegisterFileSystemForPath(
-        fileapi::kFileSystemTypeNativeMedia, std::string(), root_path(), NULL);
+        storage::kFileSystemTypeNativeMedia, std::string(), root_path(), NULL);
 
     isolated_context()->AddReference(filesystem_id_);
   }
 
   virtual void TearDown() {
     isolated_context()->RemoveReference(filesystem_id_);
     file_system_context_ = NULL;
   }
 
  protected:
-  fileapi::FileSystemContext* file_system_context() {
+  storage::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,
+        storage::kFileSystemTypeIsolated,
         GetVirtualPath(test_case_path));
   }
 
-  fileapi::IsolatedContext* isolated_context() {
-    return fileapi::IsolatedContext::GetInstance();
+  storage::IsolatedContext* isolated_context() {
+    return storage::IsolatedContext::GetInstance();
   }
 
   base::FilePath root_path() {
     return data_dir_.path().Append(FPL("Media Directory"));
   }
 
   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));
   }
 
   GURL origin() {
     return GURL("http://example.com");
   }
 
-  fileapi::FileSystemType type() {
-    return fileapi::kFileSystemTypeNativeMedia;
-  }
+  storage::FileSystemType type() { return storage::kFileSystemTypeNativeMedia; }
 
-  fileapi::FileSystemOperationRunner* operation_runner() {
+  storage::FileSystemOperationRunner* operation_runner() {
     return file_system_context_->operation_runner();
   }
 
  private:
   base::MessageLoop message_loop_;
   content::TestBrowserThread io_thread_;
 
   base::ScopedTempDir data_dir_;
-  scoped_refptr<fileapi::FileSystemContext> file_system_context_;
+  scoped_refptr<storage::FileSystemContext> file_system_context_;
 
   std::string filesystem_id_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeMediaFileUtilTest);
 };
 
 TEST_F(NativeMediaFileUtilTest, DirectoryExistsAndFileExistsFiltering) {
   PopulateDirectoryWithTestCases(root_path(),
                                  kFilteringTestCases,
                                  arraysize(kFilteringTestCases));
@@ skipping 91 matching lines @@
           "CopySourceFiltering run %d test %" PRIuS, loop_count, i);
       base::File::Error expectation = base::File::FILE_OK;
       if (loop_count == 0 || !kFilteringTestCases[i].visible) {
         // If the source does not exist or is not visible.
         expectation = base::File::FILE_ERROR_NOT_FOUND;
       } else if (!kFilteringTestCases[i].is_directory) {
         // Cannot copy a visible file to a directory.
         expectation = base::File::FILE_ERROR_INVALID_OPERATION;
       }
       operation_runner()->Copy(
-          url, dest_url,
-          fileapi::FileSystemOperation::OPTION_NONE,
-          fileapi::FileSystemOperationRunner::CopyProgressCallback(),
+          url,
+          dest_url,
+          storage::FileSystemOperation::OPTION_NONE,
+          storage::FileSystemOperationRunner::CopyProgressCallback(),
           base::Bind(&ExpectEqHelper, test_name, expectation));
       base::MessageLoop::current()->RunUntilIdle();
     }
   }
 }
 
 TEST_F(NativeMediaFileUtilTest, CopyDestFiltering) {
   // Run the loop twice. The first run has no destination files.
   // The second run does.
   for (int loop_count = 0; loop_count < 2; ++loop_count) {
@@ skipping 42 matching lines @@
           expectation = base::File::FILE_ERROR_SECURITY;
         } else if (kFilteringTestCases[i].is_directory) {
           // Cannot copy a file to a directory.
           expectation = base::File::FILE_ERROR_INVALID_OPERATION;
         } else {
           // Copying from a file to a visible file that exists is ok.
           expectation = base::File::FILE_OK;
         }
       }
       operation_runner()->Copy(
-          src_url, url,
-          fileapi::FileSystemOperation::OPTION_NONE,
-          fileapi::FileSystemOperationRunner::CopyProgressCallback(),
+          src_url,
+          url,
+          storage::FileSystemOperation::OPTION_NONE,
+          storage::FileSystemOperationRunner::CopyProgressCallback(),
           base::Bind(&ExpectEqHelper, test_name, expectation));
       base::MessageLoop::current()->RunUntilIdle();
     }
   }
 }
 
 TEST_F(NativeMediaFileUtilTest, MoveSourceFiltering) {
   base::FilePath dest_path = root_path().AppendASCII("dest");
   FileSystemURL dest_url = CreateURL(FPL("dest"));
 
@@ skipping 17 matching lines @@
           "MoveSourceFiltering run %d test %" PRIuS, loop_count, i);
       base::File::Error expectation = base::File::FILE_OK;
       if (loop_count == 0 || !kFilteringTestCases[i].visible) {
         // If the source does not exist or is not visible.
         expectation = base::File::FILE_ERROR_NOT_FOUND;
       } else if (!kFilteringTestCases[i].is_directory) {
         // Cannot move a visible file to a directory.
         expectation = base::File::FILE_ERROR_INVALID_OPERATION;
       }
       operation_runner()->Move(
-          url, dest_url, fileapi::FileSystemOperation::OPTION_NONE,
+          url,
+          dest_url,
+          storage::FileSystemOperation::OPTION_NONE,
           base::Bind(&ExpectEqHelper, test_name, expectation));
       base::MessageLoop::current()->RunUntilIdle();
     }
   }
 }
 
 TEST_F(NativeMediaFileUtilTest, MoveDestFiltering) {
   // Run the loop twice. The first run has no destination files.
   // The second run does.
   for (int loop_count = 0; loop_count < 2; ++loop_count) {
@@ skipping 44 matching lines @@
           expectation = base::File::FILE_ERROR_SECURITY;
         } else if (kFilteringTestCases[i].is_directory) {
           // Cannot move a file to a directory.
           expectation = base::File::FILE_ERROR_INVALID_OPERATION;
         } else {
           // Moving from a file to a visible file that exists is ok.
           expectation = base::File::FILE_OK;
         }
       }
       operation_runner()->Move(
-          src_url, url, fileapi::FileSystemOperation::OPTION_NONE,
+          src_url,
+          url,
+          storage::FileSystemOperation::OPTION_NONE,
           base::Bind(&ExpectEqHelper, test_name, expectation));
       base::MessageLoop::current()->RunUntilIdle();
     }
   }
 }
 
 TEST_F(NativeMediaFileUtilTest, GetMetadataFiltering) {
   // Run the loop twice. The first run has no files. The second run does.
   for (int loop_count = 0; loop_count < 2; ++loop_count) {
     if (loop_count == 1) {
@@ skipping 49 matching lines @@
       base::MessageLoop::current()->RunUntilIdle();
     }
   }
 }
 
 void CreateSnapshotCallback(
     base::File::Error* error,
     base::File::Error result,
     const base::File::Info&,
     const base::FilePath&,
-    const scoped_refptr<webkit_blob::ShareableFileReference>&) {
+    const scoped_refptr<storage::ShareableFileReference>&) {
   *error = result;
 }
 
 TEST_F(NativeMediaFileUtilTest, CreateSnapshot) {
   PopulateDirectoryWithTestCases(root_path(),
                                  kFilteringTestCases,
                                  arraysize(kFilteringTestCases));
   for (size_t i = 0; i < arraysize(kFilteringTestCases); ++i) {
     if (kFilteringTestCases[i].is_directory ||
         !kFilteringTestCases[i].visible) {
       continue;
     }
     FileSystemURL root_url = CreateURL(FPL(""));
     FileSystemURL url = CreateURL(kFilteringTestCases[i].path);
     base::File::Error expected_error, error;
     if (kFilteringTestCases[i].media_file)
       expected_error = base::File::FILE_OK;
     else
       expected_error = base::File::FILE_ERROR_SECURITY;
     error = base::File::FILE_ERROR_FAILED;
     operation_runner()->CreateSnapshotFile(url,
         base::Bind(CreateSnapshotCallback, &error));
     base::MessageLoop::current()->RunUntilIdle();
     ASSERT_EQ(expected_error, error);
   }
 }