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

chrome/browser/media_galleries/fileapi/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 <vector>
 
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
@@ skipping 19 matching lines @@
 #include "content/public/test/test_file_system_options.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/browser/fileapi/async_file_util.h"
 #include "webkit/browser/fileapi/external_mount_points.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_operation_context.h"
 #include "webkit/browser/fileapi/file_system_operation_runner.h"
 #include "webkit/browser/fileapi/isolated_context.h"
 #include "webkit/common/blob/shareable_file_reference.h"
 
-using fileapi::FileSystemOperationContext;
-using fileapi::FileSystemOperation;
-using fileapi::FileSystemURL;
+using storage::FileSystemOperationContext;
+using storage::FileSystemOperation;
+using storage::FileSystemURL;
 
 namespace picasa {
 
 namespace {
 
 base::Time::Exploded test_date_exploded = { 2013, 4, 0, 16, 0, 0, 0, 0 };
 
 bool WriteJPEGHeader(const base::FilePath& path) {
   const char kJpegHeader[] = "\xFF\xD8\xFF";  // Per HTML5 specification.
   return base::WriteFile(path, kJpegHeader, arraysize(kJpegHeader)) != -1;
@@ skipping 82 matching lines @@
     FileSystemOperation::FileEntryList* contents,
     bool* completed, base::File::Error error,
     const FileSystemOperation::FileEntryList& file_list,
     bool has_more) {
   DCHECK(!*completed);
   *completed = !has_more && error == base::File::FILE_OK;
   *contents = file_list;
   run_loop->Quit();
 }
 
-void ReadDirectoryTestHelper(fileapi::FileSystemOperationRunner* runner,
+void ReadDirectoryTestHelper(storage::FileSystemOperationRunner* runner,
                              const FileSystemURL& url,
                              FileSystemOperation::FileEntryList* contents,
                              bool* completed) {
   DCHECK(contents);
   DCHECK(completed);
   base::RunLoop run_loop;
   runner->ReadDirectory(
       url, base::Bind(&ReadDirectoryTestHelperCallback, &run_loop, contents,
                       completed));
   run_loop.Run();
 }
 
 void SynchronouslyRunOnMediaTaskRunner(const base::Closure& closure) {
   base::RunLoop loop;
   MediaFileSystemBackend::MediaTaskRunner()->PostTaskAndReply(
       FROM_HERE,
       closure,
       loop.QuitClosure());
   loop.Run();
 }
 
 void CreateSnapshotFileTestHelperCallback(
     base::RunLoop* run_loop,
     base::File::Error* error,
     base::FilePath* platform_path_result,
     base::File::Error result,
     const base::File::Info& file_info,
     const base::FilePath& platform_path,
-    const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref) {
+    const scoped_refptr<storage::ShareableFileReference>& file_ref) {
   DCHECK(run_loop);
   DCHECK(error);
   DCHECK(platform_path_result);
 
   *error = result;
   *platform_path_result = platform_path;
   run_loop->Quit();
 }
 
 }  // namespace
@@ skipping 15 matching lines @@
 };
 
 class TestMediaFileSystemBackend : public MediaFileSystemBackend {
  public:
   TestMediaFileSystemBackend(const base::FilePath& profile_path,
                              PicasaFileUtil* picasa_file_util)
       : MediaFileSystemBackend(profile_path,
                                MediaFileSystemBackend::MediaTaskRunner().get()),
         test_file_util_(picasa_file_util) {}
 
-  virtual fileapi::AsyncFileUtil*
-  GetAsyncFileUtil(fileapi::FileSystemType type) OVERRIDE {
-    if (type != fileapi::kFileSystemTypePicasa)
+  virtual storage::AsyncFileUtil* GetAsyncFileUtil(
+      storage::FileSystemType type) OVERRIDE {
+    if (type != storage::kFileSystemTypePicasa)
       return NULL;
 
     return test_file_util_.get();
   }
 
  private:
-  scoped_ptr<fileapi::AsyncFileUtil> test_file_util_;
+  scoped_ptr<storage::AsyncFileUtil> test_file_util_;
 };
 
 class PicasaFileUtilTest : public testing::Test {
  public:
   PicasaFileUtilTest()
       : io_thread_(content::BrowserThread::IO, &message_loop_) {
   }
   virtual ~PicasaFileUtilTest() {}
 
   virtual void SetUp() OVERRIDE {
     ASSERT_TRUE(profile_dir_.CreateUniqueTempDir());
     ImportedMediaGalleryRegistry::GetInstance()->Initialize();
 
-    scoped_refptr<quota::SpecialStoragePolicy> storage_policy =
+    scoped_refptr<storage::SpecialStoragePolicy> storage_policy =
         new content::MockSpecialStoragePolicy();
 
     SynchronouslyRunOnMediaTaskRunner(base::Bind(
         &PicasaFileUtilTest::SetUpOnMediaTaskRunner, base::Unretained(this)));
 
     media_path_filter_.reset(new MediaPathFilter());
 
-    ScopedVector<fileapi::FileSystemBackend> additional_providers;
+    ScopedVector<storage::FileSystemBackend> additional_providers;
     additional_providers.push_back(new TestMediaFileSystemBackend(
         profile_dir_.path(),
         new TestPicasaFileUtil(media_path_filter_.get(),
                                picasa_data_provider_.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>(),
         profile_dir_.path(),
         content::CreateAllowFileAccessOptions());
   }
 
   virtual void TearDown() OVERRIDE {
     SynchronouslyRunOnMediaTaskRunner(
         base::Bind(&PicasaFileUtilTest::TearDownOnMediaTaskRunner,
                    base::Unretained(this)));
   }
 
@@ skipping 91 matching lines @@
     ASSERT_TRUE(completed);
     EXPECT_EQ(0u, contents.size());
   }
 
   FileSystemURL CreateURL(const std::string& path) const {
     base::FilePath virtual_path =
         ImportedMediaGalleryRegistry::GetInstance()->ImportedRoot();
     virtual_path = virtual_path.AppendASCII("picasa");
     virtual_path = virtual_path.AppendASCII(path);
     return file_system_context_->CreateCrackedFileSystemURL(
-        GURL("http://www.example.com"), fileapi::kFileSystemTypePicasa,
+        GURL("http://www.example.com"),
+        storage::kFileSystemTypePicasa,
         virtual_path);
   }
 
-  fileapi::FileSystemOperationRunner* operation_runner() const {
+  storage::FileSystemOperationRunner* operation_runner() const {
     return file_system_context_->operation_runner();
   }
 
-  scoped_refptr<fileapi::FileSystemContext> file_system_context() const {
+  scoped_refptr<storage::FileSystemContext> file_system_context() const {
     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_refptr<storage::FileSystemContext> file_system_context_;
   scoped_ptr<PicasaDataProvider> picasa_data_provider_;
   scoped_ptr<MediaPathFilter> media_path_filter_;
 
   DISALLOW_COPY_AND_ASSIGN(PicasaFileUtilTest);
 };
 
 TEST_F(PicasaFileUtilTest, DateFormat) {
   base::Time::Exploded exploded_shortmonth = { 2013, 4, 0, 16, 0, 0, 0, 0 };
   base::Time shortmonth = base::Time::FromLocalExploded(exploded_shortmonth);
 
@@ skipping 181 matching lines @@
   ASSERT_TRUE(completed);
   EXPECT_EQ(1u, contents.size());
   EXPECT_EQ("mapped_name.jpg",
             base::FilePath(contents.begin()->name).AsUTF8Unsafe());
   EXPECT_FALSE(contents.begin()->is_directory);
 
   // Create a snapshot file to verify the file path.
   base::RunLoop loop;
   base::File::Error error;
   base::FilePath platform_path_result;
-  fileapi::FileSystemOperationRunner::SnapshotFileCallback snapshot_callback =
+  storage::FileSystemOperationRunner::SnapshotFileCallback snapshot_callback =
       base::Bind(&CreateSnapshotFileTestHelperCallback,
                  &loop,
                  &error,
                  &platform_path_result);
   operation_runner()->CreateSnapshotFile(
       CreateURL(std::string(kPicasaDirAlbums) +
                 "/albumname 2013-04-16/mapped_name.jpg"),
       snapshot_callback);
   loop.Run();
   EXPECT_EQ(base::File::FILE_OK, error);
   EXPECT_EQ(image_path, platform_path_result);
 }
 
 }  // namespace picasa