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

chrome/browser/media_galleries/fileapi/media_file_validator_browsertest.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 "base/basictypes.h"
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 89 matching lines @@
  private:
   // Create the test files, filesystem objects, etc.
   void SetupOnFileThread(const std::string& filename,
                          const std::string& content,
                          bool expected_result) {
     ASSERT_TRUE(base_dir_.CreateUniqueTempDir());
     base::FilePath base = base_dir_.path();
     base::FilePath src_path = base.AppendASCII("src_fs");
     ASSERT_TRUE(base::CreateDirectory(src_path));
 
-    ScopedVector<fileapi::FileSystemBackend> additional_providers;
+    ScopedVector<storage::FileSystemBackend> additional_providers;
     additional_providers.push_back(new content::TestFileSystemBackend(
         base::MessageLoopProxy::current().get(), src_path));
     additional_providers.push_back(new MediaFileSystemBackend(
         base, base::MessageLoopProxy::current().get()));
     file_system_context_ =
         content::CreateFileSystemContextWithAdditionalProvidersForTesting(
             NULL, additional_providers.Pass(), base);
 
     move_src_ = file_system_context_->CreateCrackedFileSystemURL(
-        GURL(kOrigin), fileapi::kFileSystemTypeTest,
+        GURL(kOrigin),
+        storage::kFileSystemTypeTest,
         base::FilePath::FromUTF8Unsafe(filename));
 
     test_file_size_ = content.size();
     base::FilePath test_file = src_path.AppendASCII(filename);
     ASSERT_EQ(test_file_size_,
               base::WriteFile(test_file, content.data(), test_file_size_));
 
     base::FilePath dest_path = base.AppendASCII("dest_fs");
     ASSERT_TRUE(base::CreateDirectory(dest_path));
     std::string dest_fsid =
-        fileapi::IsolatedContext::GetInstance()->RegisterFileSystemForPath(
-            fileapi::kFileSystemTypeNativeMedia, std::string(), dest_path,
+        storage::IsolatedContext::GetInstance()->RegisterFileSystemForPath(
+            storage::kFileSystemTypeNativeMedia,
+            std::string(),
+            dest_path,
             NULL);
 
     size_t extension_index = filename.find_last_of(".");
     ASSERT_NE(std::string::npos, extension_index);
     std::string extension = filename.substr(extension_index);
-    std::string dest_root_fs_url = fileapi::GetIsolatedFileSystemRootURIString(
+    std::string dest_root_fs_url = storage::GetIsolatedFileSystemRootURIString(
         GURL(kOrigin), dest_fsid, "dest_fs/");
     move_dest_ = file_system_context_->CrackURL(GURL(
           dest_root_fs_url + "move_dest" + extension));
 
     content::BrowserThread::PostTask(
         content::BrowserThread::IO,
         FROM_HERE,
         base::Bind(&MediaFileValidatorTest::CheckFiles,
                    base::Unretained(this), true,
                    base::Bind(&MediaFileValidatorTest::OnTestFilesReady,
@@ skipping 14 matching lines @@
   void CheckFiles(bool src_expected,
                   const base::Callback<void(bool success)>& callback) {
     CheckFile(move_src_, src_expected ? test_file_size_ : kNoFileSize,
               base::Bind(&MediaFileValidatorTest::OnCheckFilesFirstResult,
                          base::Unretained(this), !src_expected, callback));
   }
 
   // Helper that checks a file has the |expected_size|, which may be
   // |kNoFileSize| if the file should not exist.  |callback| is called
   // with success/failure.
-  void CheckFile(fileapi::FileSystemURL url,
+  void CheckFile(storage::FileSystemURL url,
                  int64 expected_size,
                  const base::Callback<void(bool success)>& callback) {
     operation_runner()->GetMetadata(url,
                                     base::Bind(&HandleCheckFileResult,
                                                expected_size, callback));
   }
 
   // Helper that checks the result of |move_src_| lookup and then checks
   // |move_dest_| if all is as expected.
   void OnCheckFilesFirstResult(bool dest_expected,
                                const base::Callback<void(bool)>& callback,
                                bool src_result) {
     EXPECT_TRUE(src_result);
     if (!src_result) {
       callback.Run(false);
       return;
     }
     CheckFile(move_dest_, dest_expected ? test_file_size_ : kNoFileSize,
               callback);
   }
 
   // Assert |test_files_ready| and then do the actual test of moving
   // |move_src_| to |move_dest_|.
   void OnTestFilesReady(bool expected_result, bool test_files_ready) {
     ASSERT_TRUE(test_files_ready);
-    operation_runner()->Move(
-        move_src_, move_dest_, fileapi::FileSystemOperation::OPTION_NONE,
-        base::Bind(&MediaFileValidatorTest::OnMoveResult,
-                   base::Unretained(this), expected_result));
+    operation_runner()->Move(move_src_,
+                             move_dest_,
+                             storage::FileSystemOperation::OPTION_NONE,
+                             base::Bind(&MediaFileValidatorTest::OnMoveResult,
+                                        base::Unretained(this),
+                                        expected_result));
   }
 
   // Check that the move succeeded/failed based on expectation and then
   // check that the right file exists.
   void OnMoveResult(bool expected_result, base::File::Error result) {
     if (expected_result)
       EXPECT_EQ(base::File::FILE_OK, result);
     else
       EXPECT_EQ(base::File::FILE_ERROR_SECURITY, result);
     CheckFiles(!expected_result,
                base::Bind(&MediaFileValidatorTest::OnTestFilesCheckResult,
                           base::Unretained(this)));
   }
 
   // Check that the correct test file exists and then post the result back
   // to the UI thread.
   void OnTestFilesCheckResult(bool result) {
     EXPECT_TRUE(result);
     content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
                                      loop_runner_->QuitClosure());
   }
 
-  fileapi::FileSystemOperationRunner* operation_runner() {
+  storage::FileSystemOperationRunner* operation_runner() {
     return file_system_context_->operation_runner();
   }
 
   base::ScopedTempDir base_dir_;
 
-  scoped_refptr<fileapi::FileSystemContext> file_system_context_;
+  scoped_refptr<storage::FileSystemContext> file_system_context_;
 
   int test_file_size_;
 
-  fileapi::FileSystemURL move_src_;
-  fileapi::FileSystemURL move_dest_;
+  storage::FileSystemURL move_src_;
+  storage::FileSystemURL move_dest_;
 
   scoped_refptr<content::MessageLoopRunner> loop_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaFileValidatorTest);
 };
 
 IN_PROC_BROWSER_TEST_F(MediaFileValidatorTest, UnsupportedExtension) {
   MoveTest("a.txt", std::string(kValidImage, arraysize(kValidImage)), false);
 }
 
@@ skipping 24 matching lines @@
   test_file = test_file.AppendASCII("no_streams.webm");
   MoveTestFromFile("no_streams.webm", test_file, false);
 }
 
 IN_PROC_BROWSER_TEST_F(MediaFileValidatorTest, ValidVideo) {
   base::FilePath test_file = GetMediaTestDir();
   ASSERT_FALSE(test_file.empty());
   test_file = test_file.AppendASCII("bear-320x240-multitrack.webm");
   MoveTestFromFile("multitrack.webm", test_file, true);
 }