Collapse fileapi, webkit_blob, webkit_database, quota, and webkit_common namespaces into single storage namespace

As discussed here:
https://groups.google.com/a/chromium.org/forum/#!topic/storage-dev/aQall8GOrS4

BUG=338338
TBR=cevans
NOTRY=true

Review URL: https://codereview.chromium.org/492873002

Cr-Commit-Position: refs/heads/master@{#291485}
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@291485 0039d316-1c4b-4281-b951-d872f2087c98

49 files changed, 758 insertions, 802 deletions

diff --git a/content/browser/fileapi/blob_storage_context_unittest.cc b/content/browser/fileapi/blob_storage_context_unittest.cc
index 823679e..81d873a 100644
--- a/content/browser/fileapi/blob_storage_context_unittest.cc
+++ b/content/browser/fileapi/blob_storage_context_unittest.cc
@@ -13,7 +13,7 @@
 #include "webkit/browser/blob/blob_data_handle.h"
 #include "webkit/browser/blob/blob_storage_context.h"
 
-using webkit_blob::BlobDataHandle;
+using storage::BlobDataHandle;
 
 namespace content {
 
diff --git a/content/browser/fileapi/blob_storage_host.cc b/content/browser/fileapi/blob_storage_host.cc
index cc51dbb..82c8645 100644
--- a/content/browser/fileapi/blob_storage_host.cc
+++ b/content/browser/fileapi/blob_storage_host.cc
@@ -10,8 +10,8 @@
 #include "webkit/browser/blob/blob_data_handle.h"
 #include "webkit/browser/blob/blob_storage_context.h"
 
-using webkit_blob::BlobStorageContext;
-using webkit_blob::BlobData;
+using storage::BlobStorageContext;
+using storage::BlobData;
 
 namespace content {
 
diff --git a/content/browser/fileapi/blob_storage_host.h b/content/browser/fileapi/blob_storage_host.h
index 5d10d20..38e454d 100644
--- a/content/browser/fileapi/blob_storage_host.h
+++ b/content/browser/fileapi/blob_storage_host.h
@@ -16,14 +16,14 @@
 
 class GURL;
 
-namespace webkit_blob {
+namespace storage {
 class BlobDataHandle;
 class BlobStorageHost;
 class BlobStorageContext;
 }
 
-using webkit_blob::BlobStorageContext;
-using webkit_blob::BlobData;
+using storage::BlobStorageContext;
+using storage::BlobData;
 
 namespace content {
 
diff --git a/content/browser/fileapi/blob_url_request_job_unittest.cc b/content/browser/fileapi/blob_url_request_job_unittest.cc
index 4a30e11..1c3f21f 100644
--- a/content/browser/fileapi/blob_url_request_job_unittest.cc
+++ b/content/browser/fileapi/blob_url_request_job_unittest.cc
@@ -29,8 +29,8 @@
 #include "webkit/browser/fileapi/file_system_url.h"
 #include "webkit/common/blob/blob_data.h"
 
-using webkit_blob::BlobData;
-using webkit_blob::BlobURLRequestJob;
+using storage::BlobData;
+using storage::BlobURLRequestJob;
 
 namespace content {
 
@@ -47,8 +47,8 @@ const char kTestContentType[] = "foo/bar";
 const char kTestContentDisposition[] = "attachment; filename=foo.txt";
 
 const char kFileSystemURLOrigin[] = "http://remote";
-const fileapi::FileSystemType kFileSystemType =
-    fileapi::kFileSystemTypeTemporary;
+const storage::FileSystemType kFileSystemType =
+    storage::kFileSystemTypeTemporary;
 
 }  // namespace
 
@@ -114,7 +114,7 @@ class BlobURLRequestJobTest : public testing::Test {
     file_system_context_->OpenFileSystem(
         GURL(kFileSystemURLOrigin),
         kFileSystemType,
-        fileapi::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
+        storage::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
         base::Bind(&BlobURLRequestJobTest::OnValidateFileSystem,
                    base::Unretained(this)));
     base::RunLoop().RunUntilIdle();
@@ -140,7 +140,7 @@ class BlobURLRequestJobTest : public testing::Test {
   void WriteFileSystemFile(const std::string& filename,
                            const char* buf, int buf_size,
                            base::Time* modification_time) {
-    fileapi::FileSystemURL url =
+    storage::FileSystemURL url =
         file_system_context_->CreateCrackedFileSystemURL(
             GURL(kFileSystemURLOrigin),
             kFileSystemType,
@@ -243,7 +243,7 @@ class BlobURLRequestJobTest : public testing::Test {
   base::Time temp_file_system_file_modification_time2_;
 
   base::MessageLoopForIO message_loop_;
-  scoped_refptr<fileapi::FileSystemContext> file_system_context_;
+  scoped_refptr<storage::FileSystemContext> file_system_context_;
   scoped_refptr<BlobData> blob_data_;
   net::URLRequestJobFactoryImpl url_request_job_factory_;
   net::URLRequestContext url_request_context_;
diff --git a/content/browser/fileapi/browser_file_system_helper.cc b/content/browser/fileapi/browser_file_system_helper.cc
index d89d6ca..48be416 100644
--- a/content/browser/fileapi/browser_file_system_helper.cc
+++ b/content/browser/fileapi/browser_file_system_helper.cc
@@ -30,7 +30,7 @@ namespace content {
 
 namespace {
 
-using fileapi::FileSystemOptions;
+using storage::FileSystemOptions;
 
 FileSystemOptions CreateBrowserFileSystemOptions(bool is_incognito) {
   FileSystemOptions::ProfileMode profile_mode =
@@ -48,12 +48,11 @@ FileSystemOptions CreateBrowserFileSystemOptions(bool is_incognito) {
 
 }  // namespace
 
-scoped_refptr<fileapi::FileSystemContext> CreateFileSystemContext(
+scoped_refptr<storage::FileSystemContext> CreateFileSystemContext(
     BrowserContext* browser_context,
     const base::FilePath& profile_path,
     bool is_incognito,
-    quota::QuotaManagerProxy* quota_manager_proxy) {
-
+    storage::QuotaManagerProxy* quota_manager_proxy) {
   base::SequencedWorkerPool* pool = BrowserThread::GetBlockingPool();
   scoped_refptr<base::SequencedTaskRunner> file_task_runner =
       pool->GetSequencedTaskRunnerWithShutdownBehavior(
@@ -61,20 +60,20 @@ scoped_refptr<fileapi::FileSystemContext> CreateFileSystemContext(
           base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
 
   // Setting up additional filesystem backends.
-  ScopedVector<fileapi::FileSystemBackend> additional_backends;
+  ScopedVector<storage::FileSystemBackend> additional_backends;
   GetContentClient()->browser()->GetAdditionalFileSystemBackends(
       browser_context,
       profile_path,
       &additional_backends);
 
   // Set up the auto mount handlers for url requests.
-  std::vector<fileapi::URLRequestAutoMountHandler>
+  std::vector<storage::URLRequestAutoMountHandler>
       url_request_auto_mount_handlers;
   GetContentClient()->browser()->GetURLRequestAutoMountHandlers(
       &url_request_auto_mount_handlers);
 
-  scoped_refptr<fileapi::FileSystemContext> file_system_context =
-      new fileapi::FileSystemContext(
+  scoped_refptr<storage::FileSystemContext> file_system_context =
+      new storage::FileSystemContext(
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO).get(),
           file_task_runner.get(),
           BrowserContext::GetMountPoints(browser_context),
@@ -85,28 +84,27 @@ scoped_refptr<fileapi::FileSystemContext> CreateFileSystemContext(
           profile_path,
           CreateBrowserFileSystemOptions(is_incognito));
 
-  std::vector<fileapi::FileSystemType> types;
+  std::vector<storage::FileSystemType> types;
   file_system_context->GetFileSystemTypes(&types);
   for (size_t i = 0; i < types.size(); ++i) {
-    ChildProcessSecurityPolicyImpl::GetInstance()->
-        RegisterFileSystemPermissionPolicy(
+    ChildProcessSecurityPolicyImpl::GetInstance()
+        ->RegisterFileSystemPermissionPolicy(
             types[i],
-            fileapi::FileSystemContext::GetPermissionPolicy(types[i]));
+            storage::FileSystemContext::GetPermissionPolicy(types[i]));
   }
 
   return file_system_context;
 }
 
-bool FileSystemURLIsValid(
-    fileapi::FileSystemContext* context,
-    const fileapi::FileSystemURL& url) {
+bool FileSystemURLIsValid(storage::FileSystemContext* context,
+                          const storage::FileSystemURL& url) {
   if (!url.is_valid())
     return false;
 
   return context->GetFileSystemBackend(url.type()) != NULL;
 }
 
-void SyncGetPlatformPath(fileapi::FileSystemContext* context,
+void SyncGetPlatformPath(storage::FileSystemContext* context,
                          int process_id,
                          const GURL& path,
                          base::FilePath* platform_path) {
@@ -114,7 +112,7 @@ void SyncGetPlatformPath(fileapi::FileSystemContext* context,
          RunsTasksOnCurrentThread());
   DCHECK(platform_path);
   *platform_path = base::FilePath();
-  fileapi::FileSystemURL url(context->CrackURL(path));
+  storage::FileSystemURL url(context->CrackURL(path));
   if (!FileSystemURLIsValid(context, url))
     return;
 
diff --git a/content/browser/fileapi/browser_file_system_helper.h b/content/browser/fileapi/browser_file_system_helper.h
index ad44ced..e185081 100644
--- a/content/browser/fileapi/browser_file_system_helper.h
+++ b/content/browser/fileapi/browser_file_system_helper.h
@@ -9,7 +9,7 @@
 #include "content/common/content_export.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 
-namespace fileapi {
+namespace storage {
 class ExternalMountPoints;
 class FileSystemContext;
 class FileSystemURL;
@@ -21,20 +21,19 @@ class BrowserContext;
 
 // Helper method that returns FileSystemContext constructed for
 // the browser process.
-CONTENT_EXPORT scoped_refptr<fileapi::FileSystemContext>
-CreateFileSystemContext(
-    BrowserContext* browser_context,
-    const base::FilePath& profile_path,
-    bool is_incognito,
-    quota::QuotaManagerProxy* quota_manager_proxy);
+CONTENT_EXPORT scoped_refptr<storage::FileSystemContext>
+    CreateFileSystemContext(BrowserContext* browser_context,
+                            const base::FilePath& profile_path,
+                            bool is_incognito,
+                            storage::QuotaManagerProxy* quota_manager_proxy);
 
 // Verifies that |url| is valid and has a registered backend in |context|.
-CONTENT_EXPORT bool FileSystemURLIsValid(fileapi::FileSystemContext* context,
-                                         const fileapi::FileSystemURL& url);
+CONTENT_EXPORT bool FileSystemURLIsValid(storage::FileSystemContext* context,
+                                         const storage::FileSystemURL& url);
 
 // Get the platform path from a file system URL. This needs to be called
 // on the FILE thread.
-CONTENT_EXPORT void SyncGetPlatformPath(fileapi::FileSystemContext* context,
+CONTENT_EXPORT void SyncGetPlatformPath(storage::FileSystemContext* context,
                                         int process_id,
                                         const GURL& path,
                                         base::FilePath* platform_path);
diff --git a/content/browser/fileapi/chrome_blob_storage_context.cc b/content/browser/fileapi/chrome_blob_storage_context.cc
index 0b79bad..2d8aa41 100644
--- a/content/browser/fileapi/chrome_blob_storage_context.cc
+++ b/content/browser/fileapi/chrome_blob_storage_context.cc
@@ -13,7 +13,7 @@
 #include "webkit/browser/blob/blob_storage_context.h"
 
 using base::UserDataAdapter;
-using webkit_blob::BlobStorageContext;
+using storage::BlobStorageContext;
 
 namespace content {
 
@@ -23,7 +23,7 @@ const char kBlobStorageContextKeyName[] = "content_blob_storage_context";
 
 class BlobHandleImpl : public BlobHandle {
  public:
-  explicit BlobHandleImpl(scoped_ptr<webkit_blob::BlobDataHandle> handle)
+  explicit BlobHandleImpl(scoped_ptr<storage::BlobDataHandle> handle)
       : handle_(handle.Pass()) {
   }
 
@@ -34,7 +34,7 @@ class BlobHandleImpl : public BlobHandle {
   }
 
  private:
-  scoped_ptr<webkit_blob::BlobDataHandle> handle_;
+  scoped_ptr<storage::BlobDataHandle> handle_;
 };
 
 }  // namespace
@@ -71,11 +71,10 @@ scoped_ptr<BlobHandle> ChromeBlobStorageContext::CreateMemoryBackedBlob(
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   std::string uuid(base::GenerateGUID());
-  scoped_refptr<webkit_blob::BlobData> blob_data =
-      new webkit_blob::BlobData(uuid);
+  scoped_refptr<storage::BlobData> blob_data = new storage::BlobData(uuid);
   blob_data->AppendData(data, length);
 
-  scoped_ptr<webkit_blob::BlobDataHandle> blob_data_handle =
+  scoped_ptr<storage::BlobDataHandle> blob_data_handle =
       context_->AddFinishedBlob(blob_data.get());
   if (!blob_data_handle)
     return scoped_ptr<BlobHandle>();
diff --git a/content/browser/fileapi/chrome_blob_storage_context.h b/content/browser/fileapi/chrome_blob_storage_context.h
index 1dccd99..8d8a5f2 100644
--- a/content/browser/fileapi/chrome_blob_storage_context.h
+++ b/content/browser/fileapi/chrome_blob_storage_context.h
@@ -10,7 +10,7 @@
 #include "base/sequenced_task_runner_helpers.h"
 #include "content/common/content_export.h"
 
-namespace webkit_blob {
+namespace storage {
 class BlobStorageContext;
 }
 
@@ -37,9 +37,7 @@ class CONTENT_EXPORT ChromeBlobStorageContext
 
   void InitializeOnIOThread();
 
-  webkit_blob::BlobStorageContext* context() const {
-    return context_.get();
-  }
+  storage::BlobStorageContext* context() const { return context_.get(); }
 
   // Returns a NULL scoped_ptr on failure.
   scoped_ptr<BlobHandle> CreateMemoryBackedBlob(const char* data,
@@ -56,7 +54,7 @@ class CONTENT_EXPORT ChromeBlobStorageContext
 
   void DeleteOnCorrectThread() const;
 
-  scoped_ptr<webkit_blob::BlobStorageContext> context_;
+  scoped_ptr<storage::BlobStorageContext> context_;
 };
 
 struct ChromeBlobStorageContextDeleter {
diff --git a/content/browser/fileapi/copy_or_move_file_validator_unittest.cc b/content/browser/fileapi/copy_or_move_file_validator_unittest.cc
index eaff4d3..33dd9f1 100644
--- a/content/browser/fileapi/copy_or_move_file_validator_unittest.cc
+++ b/content/browser/fileapi/copy_or_move_file_validator_unittest.cc
@@ -22,17 +22,17 @@
 #include "webkit/common/fileapi/file_system_util.h"
 
 using content::AsyncFileTestHelper;
-using fileapi::CopyOrMoveFileValidator;
-using fileapi::CopyOrMoveFileValidatorFactory;
-using fileapi::FileSystemURL;
+using storage::CopyOrMoveFileValidator;
+using storage::CopyOrMoveFileValidatorFactory;
+using storage::FileSystemURL;
 
 namespace content {
 
 namespace {
 
-const fileapi::FileSystemType kNoValidatorType =
-    fileapi::kFileSystemTypeTemporary;
-const fileapi::FileSystemType kWithValidatorType = fileapi::kFileSystemTypeTest;
+const storage::FileSystemType kNoValidatorType =
+    storage::kFileSystemTypeTemporary;
+const storage::FileSystemType kWithValidatorType = storage::kFileSystemTypeTest;
 
 void ExpectOk(const GURL& origin_url,
               const std::string& name,
@@ -43,8 +43,8 @@ void ExpectOk(const GURL& origin_url,
 class CopyOrMoveFileValidatorTestHelper {
  public:
   CopyOrMoveFileValidatorTestHelper(const GURL& origin,
-                                    fileapi::FileSystemType src_type,
-                                    fileapi::FileSystemType dest_type)
+                                    storage::FileSystemType src_type,
+                                    storage::FileSystemType dest_type)
       : origin_(origin), src_type_(src_type), dest_type_(dest_type) {}
 
   ~CopyOrMoveFileValidatorTestHelper() {
@@ -59,17 +59,17 @@ class CopyOrMoveFileValidatorTestHelper {
     file_system_context_ = CreateFileSystemContextForTesting(NULL, base_dir);
 
     // Set up TestFileSystemBackend to require CopyOrMoveFileValidator.
-    fileapi::FileSystemBackend* test_file_system_backend =
+    storage::FileSystemBackend* test_file_system_backend =
         file_system_context_->GetFileSystemBackend(kWithValidatorType);
     static_cast<TestFileSystemBackend*>(test_file_system_backend)->
         set_require_copy_or_move_validator(true);
 
     // Sets up source.
-    fileapi::FileSystemBackend* src_file_system_backend =
+    storage::FileSystemBackend* src_file_system_backend =
         file_system_context_->GetFileSystemBackend(src_type_);
     src_file_system_backend->ResolveURL(
         FileSystemURL::CreateForTest(origin_, src_type_, base::FilePath()),
-        fileapi::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
+        storage::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
         base::Bind(&ExpectOk));
     base::RunLoop().RunUntilIdle();
     ASSERT_EQ(base::File::FILE_OK, CreateDirectory(SourceURL("")));
@@ -93,7 +93,7 @@ class CopyOrMoveFileValidatorTestHelper {
   }
 
   void SetMediaCopyOrMoveFileValidatorFactory(
-      scoped_ptr<fileapi::CopyOrMoveFileValidatorFactory> factory) {
+      scoped_ptr<storage::CopyOrMoveFileValidatorFactory> factory) {
     TestFileSystemBackend* backend = static_cast<TestFileSystemBackend*>(
         file_system_context_->GetFileSystemBackend(kWithValidatorType));
     backend->InitializeCopyOrMoveFileValidatorFactory(factory.Pass());
@@ -167,13 +167,13 @@ class CopyOrMoveFileValidatorTestHelper {
 
   const GURL origin_;
 
-  const fileapi::FileSystemType src_type_;
-  const fileapi::FileSystemType dest_type_;
+  const storage::FileSystemType src_type_;
+  const storage::FileSystemType dest_type_;
   std::string src_fsid_;
   std::string dest_fsid_;
 
   base::MessageLoop message_loop_;
-  scoped_refptr<fileapi::FileSystemContext> file_system_context_;
+  scoped_refptr<storage::FileSystemContext> file_system_context_;
 
   FileSystemURL copy_src_;
   FileSystemURL copy_dest_;
@@ -191,7 +191,7 @@ enum Validity {
 };
 
 class TestCopyOrMoveFileValidatorFactory
-    : public fileapi::CopyOrMoveFileValidatorFactory {
+    : public storage::CopyOrMoveFileValidatorFactory {
  public:
   // A factory that creates validators that accept everything or nothing.
   // TODO(gbillock): switch args to enum or something
@@ -199,7 +199,7 @@ class TestCopyOrMoveFileValidatorFactory
       : validity_(validity) {}
   virtual ~TestCopyOrMoveFileValidatorFactory() {}
 
-  virtual fileapi::CopyOrMoveFileValidator* CreateCopyOrMoveFileValidator(
+  virtual storage::CopyOrMoveFileValidator* CreateCopyOrMoveFileValidator(
       const FileSystemURL& /*src_url*/,
       const base::FilePath& /*platform_path*/) OVERRIDE {
     return new TestCopyOrMoveFileValidator(validity_);
diff --git a/content/browser/fileapi/copy_or_move_operation_delegate_unittest.cc b/content/browser/fileapi/copy_or_move_operation_delegate_unittest.cc
index f2c00fc..f16a805 100644
--- a/content/browser/fileapi/copy_or_move_operation_delegate_unittest.cc
+++ b/content/browser/fileapi/copy_or_move_operation_delegate_unittest.cc
@@ -31,14 +31,14 @@
 #include "webkit/common/fileapi/file_system_util.h"
 
 using content::AsyncFileTestHelper;
-using fileapi::CopyOrMoveOperationDelegate;
-using fileapi::FileStreamWriter;
-using fileapi::FileSystemOperation;
-using fileapi::FileSystemURL;
+using storage::CopyOrMoveOperationDelegate;
+using storage::FileStreamWriter;
+using storage::FileSystemOperation;
+using storage::FileSystemURL;
 
 namespace content {
 
-typedef fileapi::FileSystemOperation::FileEntryList FileEntryList;
+typedef storage::FileSystemOperation::FileEntryList FileEntryList;
 
 namespace {
 
@@ -48,13 +48,13 @@ void ExpectOk(const GURL& origin_url,
   ASSERT_EQ(base::File::FILE_OK, error);
 }
 
-class TestValidatorFactory : public fileapi::CopyOrMoveFileValidatorFactory {
+class TestValidatorFactory : public storage::CopyOrMoveFileValidatorFactory {
  public:
   // A factory that creates validators that accept everything or nothing.
   TestValidatorFactory() {}
   virtual ~TestValidatorFactory() {}
 
-  virtual fileapi::CopyOrMoveFileValidator* CreateCopyOrMoveFileValidator(
+  virtual storage::CopyOrMoveFileValidator* CreateCopyOrMoveFileValidator(
       const FileSystemURL& /*src_url*/,
       const base::FilePath& /*platform_path*/) OVERRIDE {
     // Move arg management to TestValidator?
@@ -62,7 +62,7 @@ class TestValidatorFactory : public fileapi::CopyOrMoveFileValidatorFactory {
   }
 
  private:
-  class TestValidator : public fileapi::CopyOrMoveFileValidator {
+  class TestValidator : public storage::CopyOrMoveFileValidator {
    public:
     explicit TestValidator(bool pre_copy_valid,
                            bool post_copy_valid,
@@ -106,14 +106,14 @@ class TestValidatorFactory : public fileapi::CopyOrMoveFileValidatorFactory {
 
 // Records CopyProgressCallback invocations.
 struct ProgressRecord {
-  fileapi::FileSystemOperation::CopyProgressType type;
+  storage::FileSystemOperation::CopyProgressType type;
   FileSystemURL source_url;
   FileSystemURL dest_url;
   int64 size;
 };
 
 void RecordProgressCallback(std::vector<ProgressRecord>* records,
-                            fileapi::FileSystemOperation::CopyProgressType type,
+                            storage::FileSystemOperation::CopyProgressType type,
                             const FileSystemURL& source_url,
                             const FileSystemURL& dest_url,
                             int64 size) {
@@ -165,8 +165,8 @@ class ScopedThreadStopper {
 class CopyOrMoveOperationTestHelper {
  public:
   CopyOrMoveOperationTestHelper(const GURL& origin,
-                                fileapi::FileSystemType src_type,
-                                fileapi::FileSystemType dest_type)
+                                storage::FileSystemType src_type,
+                                storage::FileSystemType dest_type)
       : origin_(origin), src_type_(src_type), dest_type_(dest_type) {}
 
   ~CopyOrMoveOperationTestHelper() {
@@ -201,17 +201,17 @@ class CopyOrMoveOperationTestHelper {
         CreateFileSystemContextForTesting(quota_manager_proxy_.get(), base_dir);
 
     // Prepare the origin's root directory.
-    fileapi::FileSystemBackend* backend =
+    storage::FileSystemBackend* backend =
         file_system_context_->GetFileSystemBackend(src_type_);
     backend->ResolveURL(
         FileSystemURL::CreateForTest(origin_, src_type_, base::FilePath()),
-        fileapi::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
+        storage::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
         base::Bind(&ExpectOk));
     backend = file_system_context_->GetFileSystemBackend(dest_type_);
-    if (dest_type_ == fileapi::kFileSystemTypeTest) {
+    if (dest_type_ == storage::kFileSystemTypeTest) {
       TestFileSystemBackend* test_backend =
           static_cast<TestFileSystemBackend*>(backend);
-      scoped_ptr<fileapi::CopyOrMoveFileValidatorFactory> factory(
+      scoped_ptr<storage::CopyOrMoveFileValidatorFactory> factory(
           new TestValidatorFactory);
       test_backend->set_require_copy_or_move_validator(
           require_copy_or_move_validator);
@@ -220,18 +220,18 @@ class CopyOrMoveOperationTestHelper {
     }
     backend->ResolveURL(
         FileSystemURL::CreateForTest(origin_, dest_type_, base::FilePath()),
-        fileapi::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
+        storage::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
         base::Bind(&ExpectOk));
     base::RunLoop().RunUntilIdle();
 
     // Grant relatively big quota initially.
     quota_manager_->SetQuota(
         origin_,
-        fileapi::FileSystemTypeToQuotaStorageType(src_type_),
+        storage::FileSystemTypeToQuotaStorageType(src_type_),
         1024 * 1024);
     quota_manager_->SetQuota(
         origin_,
-        fileapi::FileSystemTypeToQuotaStorageType(dest_type_),
+        storage::FileSystemTypeToQuotaStorageType(dest_type_),
         1024 * 1024);
   }
 
@@ -373,23 +373,23 @@ class CopyOrMoveOperationTestHelper {
   }
 
  private:
-  void GetUsageAndQuota(fileapi::FileSystemType type,
+  void GetUsageAndQuota(storage::FileSystemType type,
                         int64* usage,
                         int64* quota) {
-    quota::QuotaStatusCode status = AsyncFileTestHelper::GetUsageAndQuota(
+    storage::QuotaStatusCode status = AsyncFileTestHelper::GetUsageAndQuota(
         quota_manager_.get(), origin_, type, usage, quota);
-    ASSERT_EQ(quota::kQuotaStatusOk, status);
+    ASSERT_EQ(storage::kQuotaStatusOk, status);
   }
 
  private:
   base::ScopedTempDir base_;
 
   const GURL origin_;
-  const fileapi::FileSystemType src_type_;
-  const fileapi::FileSystemType dest_type_;
+  const storage::FileSystemType src_type_;
+  const storage::FileSystemType dest_type_;
 
   base::MessageLoopForIO message_loop_;
-  scoped_refptr<fileapi::FileSystemContext> file_system_context_;
+  scoped_refptr<storage::FileSystemContext> file_system_context_;
   scoped_refptr<MockQuotaManagerProxy> quota_manager_proxy_;
   scoped_refptr<MockQuotaManager> quota_manager_;
 
@@ -398,8 +398,8 @@ class CopyOrMoveOperationTestHelper {
 
 TEST(LocalFileSystemCopyOrMoveOperationTest, CopySingleFile) {
   CopyOrMoveOperationTestHelper helper(GURL("http://foo"),
-                                       fileapi::kFileSystemTypeTemporary,
-                                       fileapi::kFileSystemTypePersistent);
+                                       storage::kFileSystemTypeTemporary,
+                                       storage::kFileSystemTypePersistent);
   helper.SetUp();
 
   FileSystemURL src = helper.SourceURL("a");
@@ -427,8 +427,8 @@ TEST(LocalFileSystemCopyOrMoveOperationTest, CopySingleFile) {
 
 TEST(LocalFileSystemCopyOrMoveOperationTest, MoveSingleFile) {
   CopyOrMoveOperationTestHelper helper(GURL("http://foo"),
-                                       fileapi::kFileSystemTypeTemporary,
-                                       fileapi::kFileSystemTypePersistent);
+                                       storage::kFileSystemTypeTemporary,
+                                       storage::kFileSystemTypePersistent);
   helper.SetUp();
 
   FileSystemURL src = helper.SourceURL("a");
@@ -456,8 +456,8 @@ TEST(LocalFileSystemCopyOrMoveOperationTest, MoveSingleFile) {
 
 TEST(LocalFileSystemCopyOrMoveOperationTest, CopySingleDirectory) {
   CopyOrMoveOperationTestHelper helper(GURL("http://foo"),
-                                       fileapi::kFileSystemTypeTemporary,
-                                       fileapi::kFileSystemTypePersistent);
+                                       storage::kFileSystemTypeTemporary,
+                                       storage::kFileSystemTypePersistent);
   helper.SetUp();
 
   FileSystemURL src = helper.SourceURL("a");
@@ -485,8 +485,8 @@ TEST(LocalFileSystemCopyOrMoveOperationTest, CopySingleDirectory) {
 
 TEST(LocalFileSystemCopyOrMoveOperationTest, MoveSingleDirectory) {
   CopyOrMoveOperationTestHelper helper(GURL("http://foo"),
-                                       fileapi::kFileSystemTypeTemporary,
-                                       fileapi::kFileSystemTypePersistent);
+                                       storage::kFileSystemTypeTemporary,
+                                       storage::kFileSystemTypePersistent);
   helper.SetUp();
 
   FileSystemURL src = helper.SourceURL("a");
@@ -514,8 +514,8 @@ TEST(LocalFileSystemCopyOrMoveOperationTest, MoveSingleDirectory) {
 
 TEST(LocalFileSystemCopyOrMoveOperationTest, CopyDirectory) {
   CopyOrMoveOperationTestHelper helper(GURL("http://foo"),
-                                       fileapi::kFileSystemTypeTemporary,
-                                       fileapi::kFileSystemTypePersistent);
+                                       storage::kFileSystemTypeTemporary,
+                                       storage::kFileSystemTypePersistent);
   helper.SetUp();
 
   FileSystemURL src = helper.SourceURL("a");
@@ -554,8 +554,8 @@ TEST(LocalFileSystemCopyOrMoveOperationTest, CopyDirectory) {
 
 TEST(LocalFileSystemCopyOrMoveOperationTest, MoveDirectory) {
   CopyOrMoveOperationTestHelper helper(GURL("http://foo"),
-                                       fileapi::kFileSystemTypeTemporary,
-                                       fileapi::kFileSystemTypePersistent);
+                                       storage::kFileSystemTypeTemporary,
+                                       storage::kFileSystemTypePersistent);
   helper.SetUp();
 
   FileSystemURL src = helper.SourceURL("a");
@@ -592,8 +592,8 @@ TEST(LocalFileSystemCopyOrMoveOperationTest, MoveDirectory) {
 TEST(LocalFileSystemCopyOrMoveOperationTest,
      MoveDirectoryFailPostWriteValidation) {
   CopyOrMoveOperationTestHelper helper(GURL("http://foo"),
-                                       fileapi::kFileSystemTypeTemporary,
-                                       fileapi::kFileSystemTypeTest);
+                                       storage::kFileSystemTypeTemporary,
+                                       storage::kFileSystemTypeTest);
   helper.SetUp();
 
   FileSystemURL src = helper.SourceURL("a");
@@ -625,8 +625,8 @@ TEST(LocalFileSystemCopyOrMoveOperationTest,
 
 TEST(LocalFileSystemCopyOrMoveOperationTest, CopySingleFileNoValidator) {
   CopyOrMoveOperationTestHelper helper(GURL("http://foo"),
-                                       fileapi::kFileSystemTypeTemporary,
-                                       fileapi::kFileSystemTypeTest);
+                                       storage::kFileSystemTypeTemporary,
+                                       storage::kFileSystemTypeTest);
   helper.SetUpNoValidator();
 
   FileSystemURL src = helper.SourceURL("a");
@@ -643,8 +643,8 @@ TEST(LocalFileSystemCopyOrMoveOperationTest, CopySingleFileNoValidator) {
 
 TEST(LocalFileSystemCopyOrMoveOperationTest, ProgressCallback) {
   CopyOrMoveOperationTestHelper helper(GURL("http://foo"),
-                                       fileapi::kFileSystemTypeTemporary,
-                                       fileapi::kFileSystemTypePersistent);
+                                       storage::kFileSystemTypeTemporary,
+                                       storage::kFileSystemTypePersistent);
   helper.SetUp();
 
   FileSystemURL src = helper.SourceURL("a");
@@ -730,8 +730,8 @@ TEST(LocalFileSystemCopyOrMoveOperationTest, StreamCopyHelper) {
   scoped_refptr<base::MessageLoopProxy> task_runner =
       file_thread.message_loop_proxy();
 
-  scoped_ptr<webkit_blob::FileStreamReader> reader(
-      webkit_blob::FileStreamReader::CreateForLocalFile(
+  scoped_ptr<storage::FileStreamReader> reader(
+      storage::FileStreamReader::CreateForLocalFile(
           task_runner.get(), source_path, 0, base::Time()));
 
   scoped_ptr<FileStreamWriter> writer(FileStreamWriter::CreateForLocalFile(
@@ -786,8 +786,8 @@ TEST(LocalFileSystemCopyOrMoveOperationTest, StreamCopyHelperWithFlush) {
   scoped_refptr<base::MessageLoopProxy> task_runner =
       file_thread.message_loop_proxy();
 
-  scoped_ptr<webkit_blob::FileStreamReader> reader(
-      webkit_blob::FileStreamReader::CreateForLocalFile(
+  scoped_ptr<storage::FileStreamReader> reader(
+      storage::FileStreamReader::CreateForLocalFile(
           task_runner.get(), source_path, 0, base::Time()));
 
   scoped_ptr<FileStreamWriter> writer(FileStreamWriter::CreateForLocalFile(
@@ -837,8 +837,8 @@ TEST(LocalFileSystemCopyOrMoveOperationTest, StreamCopyHelper_Cancel) {
   scoped_refptr<base::MessageLoopProxy> task_runner =
       file_thread.message_loop_proxy();
 
-  scoped_ptr<webkit_blob::FileStreamReader> reader(
-      webkit_blob::FileStreamReader::CreateForLocalFile(
+  scoped_ptr<storage::FileStreamReader> reader(
+      storage::FileStreamReader::CreateForLocalFile(
           task_runner.get(), source_path, 0, base::Time()));
 
   scoped_ptr<FileStreamWriter> writer(FileStreamWriter::CreateForLocalFile(
diff --git a/content/browser/fileapi/dragged_file_util_unittest.cc b/content/browser/fileapi/dragged_file_util_unittest.cc
index 6bd6e10..0b87167 100644
--- a/content/browser/fileapi/dragged_file_util_unittest.cc
+++ b/content/browser/fileapi/dragged_file_util_unittest.cc
@@ -27,10 +27,10 @@
 #include "webkit/browser/fileapi/native_file_util.h"
 
 using content::AsyncFileTestHelper;
-using fileapi::FileSystemContext;
-using fileapi::FileSystemOperationContext;
-using fileapi::FileSystemType;
-using fileapi::FileSystemURL;
+using storage::FileSystemContext;
+using storage::FileSystemOperationContext;
+using storage::FileSystemType;
+using storage::FileSystemURL;
 
 namespace content {
 
@@ -100,7 +100,7 @@ class DraggedFileUtilTest : public testing::Test {
   virtual void SetUp() {
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
     ASSERT_TRUE(partition_dir_.CreateUniqueTempDir());
-    file_util_.reset(new fileapi::DraggedFileUtil());
+    file_util_.reset(new storage::DraggedFileUtil());
 
     // Register the files/directories of RegularTestCases (with random
     // root paths) as dropped files.
@@ -118,8 +118,8 @@ class DraggedFileUtilTest : public testing::Test {
   }
 
  protected:
-  fileapi::IsolatedContext* isolated_context() const {
-    return fileapi::IsolatedContext::GetInstance();
+  storage::IsolatedContext* isolated_context() const {
+    return storage::IsolatedContext::GetInstance();
   }
   const base::FilePath& root_path() const {
     return data_dir_.path();
@@ -127,7 +127,7 @@ class DraggedFileUtilTest : public testing::Test {
   FileSystemContext* file_system_context() const {
     return file_system_context_.get();
   }
-  fileapi::FileSystemFileUtil* file_util() const { return file_util_.get(); }
+  storage::FileSystemFileUtil* file_util() const { return file_util_.get(); }
   std::string filesystem_id() const { return filesystem_id_; }
 
   base::FilePath GetTestCasePlatformPath(
@@ -148,14 +148,14 @@ class DraggedFileUtilTest : public testing::Test {
         filesystem_id()).Append(path);
     return file_system_context_->CreateCrackedFileSystemURL(
         GURL("http://example.com"),
-        fileapi::kFileSystemTypeIsolated,
+        storage::kFileSystemTypeIsolated,
         virtual_path);
   }
 
   FileSystemURL GetOtherFileSystemURL(const base::FilePath& path) const {
     return file_system_context()->CreateCrackedFileSystemURL(
         GURL("http://example.com"),
-        fileapi::kFileSystemTypeTemporary,
+        storage::kFileSystemTypeTemporary,
         base::FilePath().AppendASCII("dest").Append(path));
   }
 
@@ -247,9 +247,9 @@ class DraggedFileUtilTest : public testing::Test {
     }
   }
 
-  scoped_ptr<fileapi::FileSystemOperationContext> GetOperationContext() {
-    return make_scoped_ptr(
-        new fileapi::FileSystemOperationContext(file_system_context())).Pass();
+  scoped_ptr<storage::FileSystemOperationContext> GetOperationContext() {
+    return make_scoped_ptr(new storage::FileSystemOperationContext(
+                               file_system_context())).Pass();
   }
 
 
@@ -257,7 +257,7 @@ class DraggedFileUtilTest : public testing::Test {
   void SimulateDropFiles() {
     size_t root_path_index = 0;
 
-    fileapi::IsolatedContext::FileInfoSet toplevels;
+    storage::IsolatedContext::FileInfoSet toplevels;
     for (size_t i = 0; i < kRegularFileSystemTestCaseSize; ++i) {
       const FileSystemTestCaseRecord& test_case =
           kRegularFileSystemTestCases[i];
@@ -286,7 +286,7 @@ class DraggedFileUtilTest : public testing::Test {
   std::string filesystem_id_;
   scoped_refptr<FileSystemContext> file_system_context_;
   std::map<base::FilePath, base::FilePath> toplevel_root_map_;
-  scoped_ptr<fileapi::DraggedFileUtil> file_util_;
+  scoped_ptr<storage::DraggedFileUtil> file_util_;
   DISALLOW_COPY_AND_ASSIGN(DraggedFileUtilTest);
 };
 
@@ -361,7 +361,7 @@ TEST_F(DraggedFileUtilTest, ReadDirectoryTest) {
                  << ": " << test_case.path);
 
     // Read entries in the directory to construct the expected results map.
-    typedef std::map<base::FilePath::StringType, fileapi::DirectoryEntry>
+    typedef std::map<base::FilePath::StringType, storage::DirectoryEntry>
         EntryMap;
     EntryMap expected_entry_map;
 
@@ -372,7 +372,7 @@ TEST_F(DraggedFileUtilTest, ReadDirectoryTest) {
     base::FilePath current;
     while (!(current = file_enum.Next()).empty()) {
       base::FileEnumerator::FileInfo file_info = file_enum.GetInfo();
-      fileapi::DirectoryEntry entry;
+      storage::DirectoryEntry entry;
       entry.is_directory = file_info.IsDirectory();
       entry.name = current.BaseName().value();
       entry.size = file_info.GetSize();
@@ -399,7 +399,7 @@ TEST_F(DraggedFileUtilTest, ReadDirectoryTest) {
 
     EXPECT_EQ(expected_entry_map.size(), entries.size());
     for (size_t i = 0; i < entries.size(); ++i) {
-      const fileapi::DirectoryEntry& entry = entries[i];
+      const storage::DirectoryEntry& entry = entries[i];
       EntryMap::iterator found = expected_entry_map.find(entry.name);
       EXPECT_TRUE(found != expected_entry_map.end());
       EXPECT_EQ(found->second.name, entry.name);
diff --git a/content/browser/fileapi/external_mount_points_unittest.cc b/content/browser/fileapi/external_mount_points_unittest.cc
index fa0d1f5..38cf4c7 100644
--- a/content/browser/fileapi/external_mount_points_unittest.cc
+++ b/content/browser/fileapi/external_mount_points_unittest.cc
@@ -18,13 +18,13 @@
 #define DRIVE
 #endif
 
-using fileapi::FileSystemURL;
+using storage::FileSystemURL;
 
 namespace content {
 
 TEST(ExternalMountPointsTest, AddMountPoint) {
-  scoped_refptr<fileapi::ExternalMountPoints> mount_points(
-      fileapi::ExternalMountPoints::CreateRefCounted());
+  scoped_refptr<storage::ExternalMountPoints> mount_points(
+      storage::ExternalMountPoints::CreateRefCounted());
 
   struct TestCase {
     // The mount point's name.
@@ -107,12 +107,12 @@ TEST(ExternalMountPointsTest, AddMountPoint) {
 
   // Test adding mount points.
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
-    EXPECT_EQ(kTestCases[i].success,
-              mount_points->RegisterFileSystem(
-                  kTestCases[i].name,
-                  fileapi::kFileSystemTypeNativeLocal,
-                  fileapi::FileSystemMountOption(),
-                  base::FilePath(kTestCases[i].path)))
+    EXPECT_EQ(
+        kTestCases[i].success,
+        mount_points->RegisterFileSystem(kTestCases[i].name,
+                                         storage::kFileSystemTypeNativeLocal,
+                                         storage::FileSystemMountOption(),
+                                         base::FilePath(kTestCases[i].path)))
         << "Adding mount point: " << kTestCases[i].name << " with path "
         << kTestCases[i].path;
   }
@@ -132,35 +132,35 @@ TEST(ExternalMountPointsTest, AddMountPoint) {
 }
 
 TEST(ExternalMountPointsTest, GetVirtualPath) {
-  scoped_refptr<fileapi::ExternalMountPoints> mount_points(
-      fileapi::ExternalMountPoints::CreateRefCounted());
+  scoped_refptr<storage::ExternalMountPoints> mount_points(
+      storage::ExternalMountPoints::CreateRefCounted());
 
   mount_points->RegisterFileSystem("c",
-                                   fileapi::kFileSystemTypeNativeLocal,
-                                   fileapi::FileSystemMountOption(),
+                                   storage::kFileSystemTypeNativeLocal,
+                                   storage::FileSystemMountOption(),
                                    base::FilePath(DRIVE FPL("/a/b/c")));
   // Note that "/a/b/c" < "/a/b/c(1)" < "/a/b/c/".
   mount_points->RegisterFileSystem("c(1)",
-                                   fileapi::kFileSystemTypeNativeLocal,
-                                   fileapi::FileSystemMountOption(),
+                                   storage::kFileSystemTypeNativeLocal,
+                                   storage::FileSystemMountOption(),
                                    base::FilePath(DRIVE FPL("/a/b/c(1)")));
   mount_points->RegisterFileSystem("x",
-                                   fileapi::kFileSystemTypeNativeLocal,
-                                   fileapi::FileSystemMountOption(),
+                                   storage::kFileSystemTypeNativeLocal,
+                                   storage::FileSystemMountOption(),
                                    base::FilePath(DRIVE FPL("/z/y/x")));
   mount_points->RegisterFileSystem("o",
-                                   fileapi::kFileSystemTypeNativeLocal,
-                                   fileapi::FileSystemMountOption(),
+                                   storage::kFileSystemTypeNativeLocal,
+                                   storage::FileSystemMountOption(),
                                    base::FilePath(DRIVE FPL("/m/n/o")));
   // A mount point whose name does not match its path base name.
   mount_points->RegisterFileSystem("mount",
-                                   fileapi::kFileSystemTypeNativeLocal,
-                                   fileapi::FileSystemMountOption(),
+                                   storage::kFileSystemTypeNativeLocal,
+                                   storage::FileSystemMountOption(),
                                    base::FilePath(DRIVE FPL("/root/foo")));
   // A mount point with an empty path.
   mount_points->RegisterFileSystem("empty_path",
-                                   fileapi::kFileSystemTypeNativeLocal,
-                                   fileapi::FileSystemMountOption(),
+                                   storage::kFileSystemTypeNativeLocal,
+                                   storage::FileSystemMountOption(),
                                    base::FilePath());
 
   struct TestCase {
@@ -234,57 +234,57 @@ TEST(ExternalMountPointsTest, GetVirtualPath) {
 }
 
 TEST(ExternalMountPointsTest, HandlesFileSystemMountType) {
-  scoped_refptr<fileapi::ExternalMountPoints> mount_points(
-      fileapi::ExternalMountPoints::CreateRefCounted());
+  scoped_refptr<storage::ExternalMountPoints> mount_points(
+      storage::ExternalMountPoints::CreateRefCounted());
 
   const GURL test_origin("http://chromium.org");
   const base::FilePath test_path(FPL("/mount"));
 
   // Should handle External File System.
   EXPECT_TRUE(mount_points->HandlesFileSystemMountType(
-      fileapi::kFileSystemTypeExternal));
+      storage::kFileSystemTypeExternal));
 
   // Shouldn't handle the rest.
   EXPECT_FALSE(mount_points->HandlesFileSystemMountType(
-      fileapi::kFileSystemTypeIsolated));
-  EXPECT_FALSE(mount_points->HandlesFileSystemMountType(
-      fileapi::kFileSystemTypeTemporary));
+      storage::kFileSystemTypeIsolated));
   EXPECT_FALSE(mount_points->HandlesFileSystemMountType(
-      fileapi::kFileSystemTypePersistent));
+      storage::kFileSystemTypeTemporary));
   EXPECT_FALSE(mount_points->HandlesFileSystemMountType(
-      fileapi::kFileSystemTypeTest));
+      storage::kFileSystemTypePersistent));
+  EXPECT_FALSE(
+      mount_points->HandlesFileSystemMountType(storage::kFileSystemTypeTest));
   // Not even if it's external subtype.
   EXPECT_FALSE(mount_points->HandlesFileSystemMountType(
-      fileapi::kFileSystemTypeNativeLocal));
-  EXPECT_FALSE(mount_points->HandlesFileSystemMountType(
-      fileapi::kFileSystemTypeRestrictedNativeLocal));
+      storage::kFileSystemTypeNativeLocal));
   EXPECT_FALSE(mount_points->HandlesFileSystemMountType(
-      fileapi::kFileSystemTypeDrive));
+      storage::kFileSystemTypeRestrictedNativeLocal));
+  EXPECT_FALSE(
+      mount_points->HandlesFileSystemMountType(storage::kFileSystemTypeDrive));
   EXPECT_FALSE(mount_points->HandlesFileSystemMountType(
-      fileapi::kFileSystemTypeSyncable));
+      storage::kFileSystemTypeSyncable));
 }
 
 TEST(ExternalMountPointsTest, CreateCrackedFileSystemURL) {
-  scoped_refptr<fileapi::ExternalMountPoints> mount_points(
-      fileapi::ExternalMountPoints::CreateRefCounted());
+  scoped_refptr<storage::ExternalMountPoints> mount_points(
+      storage::ExternalMountPoints::CreateRefCounted());
 
   const GURL kTestOrigin("http://chromium.org");
 
   mount_points->RegisterFileSystem("c",
-                                   fileapi::kFileSystemTypeNativeLocal,
-                                   fileapi::FileSystemMountOption(),
+                                   storage::kFileSystemTypeNativeLocal,
+                                   storage::FileSystemMountOption(),
                                    base::FilePath(DRIVE FPL("/a/b/c")));
   mount_points->RegisterFileSystem("c(1)",
-                                   fileapi::kFileSystemTypeDrive,
-                                   fileapi::FileSystemMountOption(),
+                                   storage::kFileSystemTypeDrive,
+                                   storage::FileSystemMountOption(),
                                    base::FilePath(DRIVE FPL("/a/b/c(1)")));
   mount_points->RegisterFileSystem("empty_path",
-                                   fileapi::kFileSystemTypeSyncable,
-                                   fileapi::FileSystemMountOption(),
+                                   storage::kFileSystemTypeSyncable,
+                                   storage::FileSystemMountOption(),
                                    base::FilePath());
   mount_points->RegisterFileSystem("mount",
-                                   fileapi::kFileSystemTypeDrive,
-                                   fileapi::FileSystemMountOption(),
+                                   storage::kFileSystemTypeDrive,
+                                   storage::FileSystemMountOption(),
                                    base::FilePath(DRIVE FPL("/root")));
 
   // Try cracking invalid GURL.
@@ -293,69 +293,62 @@ TEST(ExternalMountPointsTest, CreateCrackedFileSystemURL) {
 
   // Try cracking isolated path.
   FileSystemURL isolated = mount_points->CreateCrackedFileSystemURL(
-      kTestOrigin, fileapi::kFileSystemTypeIsolated, base::FilePath(FPL("c")));
+      kTestOrigin, storage::kFileSystemTypeIsolated, base::FilePath(FPL("c")));
   EXPECT_FALSE(isolated.is_valid());
 
   // Try native local which is not cracked.
   FileSystemURL native_local = mount_points->CreateCrackedFileSystemURL(
       kTestOrigin,
-      fileapi::kFileSystemTypeNativeLocal,
+      storage::kFileSystemTypeNativeLocal,
       base::FilePath(FPL("c")));
   EXPECT_FALSE(native_local.is_valid());
 
   struct TestCase {
     const base::FilePath::CharType* const path;
     bool expect_valid;
-    fileapi::FileSystemType expect_type;
+    storage::FileSystemType expect_type;
     const base::FilePath::CharType* const expect_path;
     const char* const expect_fs_id;
   };
 
   const TestCase kTestCases[] = {
-    { FPL("c/d/e"),
-      true, fileapi::kFileSystemTypeNativeLocal, DRIVE FPL("/a/b/c/d/e"), "c" },
-    { FPL("c(1)/d/e"),
-      true, fileapi::kFileSystemTypeDrive, DRIVE FPL("/a/b/c(1)/d/e"), "c(1)" },
-    { FPL("c(1)"),
-      true, fileapi::kFileSystemTypeDrive, DRIVE FPL("/a/b/c(1)"), "c(1)" },
-    { FPL("empty_path/a"),
-      true, fileapi::kFileSystemTypeSyncable, FPL("a"), "empty_path" },
-    { FPL("empty_path"),
-      true, fileapi::kFileSystemTypeSyncable, FPL(""), "empty_path" },
-    { FPL("mount/a/b"),
-      true, fileapi::kFileSystemTypeDrive, DRIVE FPL("/root/a/b"), "mount" },
-    { FPL("mount"),
-      true, fileapi::kFileSystemTypeDrive, DRIVE FPL("/root"), "mount" },
-    { FPL("cc"),
-      false, fileapi::kFileSystemTypeUnknown, FPL(""), "" },
-    { FPL(""),
-      false, fileapi::kFileSystemTypeUnknown, FPL(""), "" },
-    { FPL(".."),
-      false, fileapi::kFileSystemTypeUnknown, FPL(""), "" },
+    {FPL("c/d/e"), true, storage::kFileSystemTypeNativeLocal,
+     DRIVE FPL("/a/b/c/d/e"), "c"},
+    {FPL("c(1)/d/e"), true, storage::kFileSystemTypeDrive,
+     DRIVE FPL("/a/b/c(1)/d/e"), "c(1)"},
+    {FPL("c(1)"), true, storage::kFileSystemTypeDrive, DRIVE FPL("/a/b/c(1)"),
+     "c(1)"},
+    {FPL("empty_path/a"), true, storage::kFileSystemTypeSyncable, FPL("a"),
+     "empty_path"},
+    {FPL("empty_path"), true, storage::kFileSystemTypeSyncable, FPL(""),
+     "empty_path"},
+    {FPL("mount/a/b"), true, storage::kFileSystemTypeDrive,
+     DRIVE FPL("/root/a/b"), "mount"},
+    {FPL("mount"), true, storage::kFileSystemTypeDrive, DRIVE FPL("/root"),
+     "mount"},
+    {FPL("cc"), false, storage::kFileSystemTypeUnknown, FPL(""), ""},
+    {FPL(""), false, storage::kFileSystemTypeUnknown, FPL(""), ""},
+    {FPL(".."), false, storage::kFileSystemTypeUnknown, FPL(""), ""},
     // Absolte paths.
-    { FPL("/c/d/e"),
-      false, fileapi::kFileSystemTypeUnknown, FPL(""), "" },
-    { FPL("/c(1)/d/e"),
-      false, fileapi::kFileSystemTypeUnknown, FPL(""), "" },
-    { FPL("/empty_path"),
-      false, fileapi::kFileSystemTypeUnknown, FPL(""), "" },
+    {FPL("/c/d/e"), false, storage::kFileSystemTypeUnknown, FPL(""), ""},
+    {FPL("/c(1)/d/e"), false, storage::kFileSystemTypeUnknown, FPL(""), ""},
+    {FPL("/empty_path"), false, storage::kFileSystemTypeUnknown, FPL(""), ""},
     // PAth references parent.
-    { FPL("c/d/../e"),
-      false, fileapi::kFileSystemTypeUnknown, FPL(""), "" },
-    { FPL("/empty_path/a/../b"),
-      false, fileapi::kFileSystemTypeUnknown, FPL(""), "" },
+    {FPL("c/d/../e"), false, storage::kFileSystemTypeUnknown, FPL(""), ""},
+    {FPL("/empty_path/a/../b"), false, storage::kFileSystemTypeUnknown, FPL(""),
+     ""},
 #if defined(FILE_PATH_USES_WIN_SEPARATORS)
-    { FPL("c/d\\e"),
-      true, fileapi::kFileSystemTypeNativeLocal, DRIVE FPL("/a/b/c/d/e"), "c" },
-    { FPL("mount\\a\\b"),
-      true, fileapi::kFileSystemTypeDrive, DRIVE FPL("/root/a/b"), "mount" },
+    {FPL("c/d\\e"), true, storage::kFileSystemTypeNativeLocal,
+     DRIVE FPL("/a/b/c/d/e"), "c"},
+    {FPL("mount\\a\\b"), true, storage::kFileSystemTypeDrive,
+     DRIVE FPL("/root/a/b"), "mount"},
 #endif
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
     FileSystemURL cracked = mount_points->CreateCrackedFileSystemURL(
         kTestOrigin,
-        fileapi::kFileSystemTypeExternal,
+        storage::kFileSystemTypeExternal,
         base::FilePath(kTestCases[i].path));
 
     EXPECT_EQ(kTestCases[i].expect_valid, cracked.is_valid())
@@ -376,89 +369,82 @@ TEST(ExternalMountPointsTest, CreateCrackedFileSystemURL) {
         << "Test case index: " << i;
     EXPECT_EQ(kTestCases[i].expect_fs_id, cracked.filesystem_id())
         << "Test case index: " << i;
-    EXPECT_EQ(fileapi::kFileSystemTypeExternal, cracked.mount_type())
+    EXPECT_EQ(storage::kFileSystemTypeExternal, cracked.mount_type())
         << "Test case index: " << i;
   }
 }
 
 TEST(ExternalMountPointsTest, CrackVirtualPath) {
-  scoped_refptr<fileapi::ExternalMountPoints> mount_points(
-      fileapi::ExternalMountPoints::CreateRefCounted());
+  scoped_refptr<storage::ExternalMountPoints> mount_points(
+      storage::ExternalMountPoints::CreateRefCounted());
 
   const GURL kTestOrigin("http://chromium.org");
 
   mount_points->RegisterFileSystem("c",
-                                   fileapi::kFileSystemTypeNativeLocal,
-                                   fileapi::FileSystemMountOption(),
+                                   storage::kFileSystemTypeNativeLocal,
+                                   storage::FileSystemMountOption(),
                                    base::FilePath(DRIVE FPL("/a/b/c")));
   mount_points->RegisterFileSystem("c(1)",
-                                   fileapi::kFileSystemTypeDrive,
-                                   fileapi::FileSystemMountOption(),
+                                   storage::kFileSystemTypeDrive,
+                                   storage::FileSystemMountOption(),
                                    base::FilePath(DRIVE FPL("/a/b/c(1)")));
   mount_points->RegisterFileSystem("empty_path",
-                                   fileapi::kFileSystemTypeSyncable,
-                                   fileapi::FileSystemMountOption(),
+                                   storage::kFileSystemTypeSyncable,
+                                   storage::FileSystemMountOption(),
                                    base::FilePath());
   mount_points->RegisterFileSystem("mount",
-                                   fileapi::kFileSystemTypeDrive,
-                                   fileapi::FileSystemMountOption(),
+                                   storage::kFileSystemTypeDrive,
+                                   storage::FileSystemMountOption(),
                                    base::FilePath(DRIVE FPL("/root")));
 
   struct TestCase {
     const base::FilePath::CharType* const path;
     bool expect_valid;
-    fileapi::FileSystemType expect_type;
+    storage::FileSystemType expect_type;
     const base::FilePath::CharType* const expect_path;
     const char* const expect_name;
   };
 
   const TestCase kTestCases[] = {
-    { FPL("c/d/e"),
-      true, fileapi::kFileSystemTypeNativeLocal, DRIVE FPL("/a/b/c/d/e"), "c" },
-    { FPL("c(1)/d/e"),
-      true, fileapi::kFileSystemTypeDrive, DRIVE FPL("/a/b/c(1)/d/e"), "c(1)" },
-    { FPL("c(1)"),
-      true, fileapi::kFileSystemTypeDrive, DRIVE FPL("/a/b/c(1)"), "c(1)" },
-    { FPL("empty_path/a"),
-      true, fileapi::kFileSystemTypeSyncable, FPL("a"), "empty_path" },
-    { FPL("empty_path"),
-      true, fileapi::kFileSystemTypeSyncable, FPL(""), "empty_path" },
-    { FPL("mount/a/b"),
-      true, fileapi::kFileSystemTypeDrive, DRIVE FPL("/root/a/b"), "mount" },
-    { FPL("mount"),
-      true, fileapi::kFileSystemTypeDrive, DRIVE FPL("/root"), "mount" },
-    { FPL("cc"),
-      false, fileapi::kFileSystemTypeUnknown, FPL(""), "" },
-    { FPL(""),
-      false, fileapi::kFileSystemTypeUnknown, FPL(""), "" },
-    { FPL(".."),
-      false, fileapi::kFileSystemTypeUnknown, FPL(""), "" },
+    {FPL("c/d/e"), true, storage::kFileSystemTypeNativeLocal,
+     DRIVE FPL("/a/b/c/d/e"), "c"},
+    {FPL("c(1)/d/e"), true, storage::kFileSystemTypeDrive,
+     DRIVE FPL("/a/b/c(1)/d/e"), "c(1)"},
+    {FPL("c(1)"), true, storage::kFileSystemTypeDrive, DRIVE FPL("/a/b/c(1)"),
+     "c(1)"},
+    {FPL("empty_path/a"), true, storage::kFileSystemTypeSyncable, FPL("a"),
+     "empty_path"},
+    {FPL("empty_path"), true, storage::kFileSystemTypeSyncable, FPL(""),
+     "empty_path"},
+    {FPL("mount/a/b"), true, storage::kFileSystemTypeDrive,
+     DRIVE FPL("/root/a/b"), "mount"},
+    {FPL("mount"), true, storage::kFileSystemTypeDrive, DRIVE FPL("/root"),
+     "mount"},
+    {FPL("cc"), false, storage::kFileSystemTypeUnknown, FPL(""), ""},
+    {FPL(""), false, storage::kFileSystemTypeUnknown, FPL(""), ""},
+    {FPL(".."), false, storage::kFileSystemTypeUnknown, FPL(""), ""},
     // Absolte paths.
-    { FPL("/c/d/e"),
-      false, fileapi::kFileSystemTypeUnknown, FPL(""), "" },
-    { FPL("/c(1)/d/e"),
-      false, fileapi::kFileSystemTypeUnknown, FPL(""), "" },
-    { FPL("/empty_path"),
-      false, fileapi::kFileSystemTypeUnknown, FPL(""), "" },
+    {FPL("/c/d/e"), false, storage::kFileSystemTypeUnknown, FPL(""), ""},
+    {FPL("/c(1)/d/e"), false, storage::kFileSystemTypeUnknown, FPL(""), ""},
+    {FPL("/empty_path"), false, storage::kFileSystemTypeUnknown, FPL(""), ""},
     // PAth references parent.
-    { FPL("c/d/../e"),
-      false, fileapi::kFileSystemTypeUnknown, FPL(""), "" },
-    { FPL("/empty_path/a/../b"),
-      false, fileapi::kFileSystemTypeUnknown, FPL(""), "" },
+    {FPL("c/d/../e"), false, storage::kFileSystemTypeUnknown, FPL(""), ""},
+    {FPL("/empty_path/a/../b"), false, storage::kFileSystemTypeUnknown, FPL(""),
+     ""},
 #if defined(FILE_PATH_USES_WIN_SEPARATORS)
-    { FPL("c/d\\e"),
-      true, fileapi::kFileSystemTypeNativeLocal, DRIVE FPL("/a/b/c/d/e"), "c" },
-    { FPL("mount\\a\\b"),
-      true, fileapi::kFileSystemTypeDrive, DRIVE FPL("/root/a/b"), "mount" },
+    {FPL("c/d\\e"), true, storage::kFileSystemTypeNativeLocal,
+     DRIVE FPL("/a/b/c/d/e"), "c"},
+    {FPL("mount\\a\\b"), true, storage::kFileSystemTypeDrive,
+     DRIVE FPL("/root/a/b"), "mount"},
 #endif
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
     std::string cracked_name;
-    fileapi::FileSystemType cracked_type;
+    storage::FileSystemType cracked_type;
     std::string cracked_id;
     base::FilePath cracked_path;
-    fileapi::FileSystemMountOption cracked_option;
+    storage::FileSystemMountOption cracked_option;
     EXPECT_EQ(kTestCases[i].expect_valid,
               mount_points->CrackVirtualPath(base::FilePath(kTestCases[i].path),
                   &cracked_name, &cracked_type, &cracked_id, &cracked_path,
@@ -482,33 +468,33 @@ TEST(ExternalMountPointsTest, CrackVirtualPath) {
 }
 
 TEST(ExternalMountPointsTest, MountOption) {
-  scoped_refptr<fileapi::ExternalMountPoints> mount_points(
-      fileapi::ExternalMountPoints::CreateRefCounted());
+  scoped_refptr<storage::ExternalMountPoints> mount_points(
+      storage::ExternalMountPoints::CreateRefCounted());
 
   mount_points->RegisterFileSystem(
       "nosync",
-      fileapi::kFileSystemTypeNativeLocal,
-      fileapi::FileSystemMountOption(fileapi::COPY_SYNC_OPTION_NO_SYNC),
+      storage::kFileSystemTypeNativeLocal,
+      storage::FileSystemMountOption(storage::COPY_SYNC_OPTION_NO_SYNC),
       base::FilePath(DRIVE FPL("/nosync")));
   mount_points->RegisterFileSystem(
       "sync",
-      fileapi::kFileSystemTypeNativeLocal,
-      fileapi::FileSystemMountOption(fileapi::COPY_SYNC_OPTION_SYNC),
+      storage::kFileSystemTypeNativeLocal,
+      storage::FileSystemMountOption(storage::COPY_SYNC_OPTION_SYNC),
       base::FilePath(DRIVE FPL("/sync")));
 
   std::string name;
-  fileapi::FileSystemType type;
+  storage::FileSystemType type;
   std::string cracked_id;
-  fileapi::FileSystemMountOption option;
+  storage::FileSystemMountOption option;
   base::FilePath path;
   EXPECT_TRUE(mount_points->CrackVirtualPath(
       base::FilePath(FPL("nosync/file")), &name, &type, &cracked_id, &path,
       &option));
-  EXPECT_EQ(fileapi::COPY_SYNC_OPTION_NO_SYNC, option.copy_sync_option());
+  EXPECT_EQ(storage::COPY_SYNC_OPTION_NO_SYNC, option.copy_sync_option());
   EXPECT_TRUE(mount_points->CrackVirtualPath(
       base::FilePath(FPL("sync/file")), &name, &type, &cracked_id, &path,
       &option));
-  EXPECT_EQ(fileapi::COPY_SYNC_OPTION_SYNC, option.copy_sync_option());
+  EXPECT_EQ(storage::COPY_SYNC_OPTION_SYNC, option.copy_sync_option());
 }
 
 }  // namespace content
diff --git a/content/browser/fileapi/file_system_browsertest.cc b/content/browser/fileapi/file_system_browsertest.cc
index 51fc416..5c84915 100644
--- a/content/browser/fileapi/file_system_browsertest.cc
+++ b/content/browser/fileapi/file_system_browsertest.cc
@@ -18,7 +18,7 @@
 #include "content/shell/browser/shell.h"
 #include "webkit/browser/quota/quota_manager.h"
 
-using quota::QuotaManager;
+using storage::QuotaManager;
 
 namespace content {
 
@@ -70,7 +70,7 @@ class FileSystemBrowserTestWithLowQuota : public FileSystemBrowserTest {
       return;
     }
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-    qm->SetTemporaryGlobalOverrideQuota(bytes, quota::QuotaCallback());
+    qm->SetTemporaryGlobalOverrideQuota(bytes, storage::QuotaCallback());
     // Don't return until the quota has been set.
     scoped_refptr<base::ThreadTestHelper> helper(new base::ThreadTestHelper(
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::DB).get()));
diff --git a/content/browser/fileapi/file_system_context_unittest.cc b/content/browser/fileapi/file_system_context_unittest.cc
index e746a6a..9fddf65 100644
--- a/content/browser/fileapi/file_system_context_unittest.cc
+++ b/content/browser/fileapi/file_system_context_unittest.cc
@@ -23,12 +23,12 @@
 #define DRIVE
 #endif
 
-using fileapi::ExternalMountPoints;
-using fileapi::FileSystemBackend;
-using fileapi::FileSystemContext;
-using fileapi::FileSystemMountOption;
-using fileapi::FileSystemURL;
-using fileapi::IsolatedContext;
+using storage::ExternalMountPoints;
+using storage::FileSystemBackend;
+using storage::FileSystemContext;
+using storage::FileSystemMountOption;
+using storage::FileSystemURL;
+using storage::IsolatedContext;
 
 namespace content {
 
@@ -64,7 +64,7 @@ class FileSystemContextTest : public testing::Test {
 
  protected:
   FileSystemContext* CreateFileSystemContextForTest(
-      fileapi::ExternalMountPoints* external_mount_points) {
+      storage::ExternalMountPoints* external_mount_points) {
     return new FileSystemContext(
         base::MessageLoopProxy::current().get(),
         base::MessageLoopProxy::current().get(),
@@ -72,7 +72,7 @@ class FileSystemContextTest : public testing::Test {
         storage_policy_.get(),
         mock_quota_manager_->proxy(),
         ScopedVector<FileSystemBackend>(),
-        std::vector<fileapi::URLRequestAutoMountHandler>(),
+        std::vector<storage::URLRequestAutoMountHandler>(),
         data_dir_.path(),
         CreateAllowFileAccessOptions());
   }
@@ -80,8 +80,8 @@ class FileSystemContextTest : public testing::Test {
   // Verifies a *valid* filesystem url has expected values.
   void ExpectFileSystemURLMatches(const FileSystemURL& url,
                                   const GURL& expect_origin,
-                                  fileapi::FileSystemType expect_mount_type,
-                                  fileapi::FileSystemType expect_type,
+                                  storage::FileSystemType expect_mount_type,
+                                  storage::FileSystemType expect_type,
                                   const base::FilePath& expect_path,
                                   const base::FilePath& expect_virtual_path,
                                   const std::string& expect_filesystem_id) {
@@ -98,7 +98,7 @@ class FileSystemContextTest : public testing::Test {
  private:
   base::ScopedTempDir data_dir_;
   base::MessageLoop message_loop_;
-  scoped_refptr<quota::SpecialStoragePolicy> storage_policy_;
+  scoped_refptr<storage::SpecialStoragePolicy> storage_policy_;
   scoped_refptr<MockQuotaManager> mock_quota_manager_;
 };
 
@@ -113,14 +113,14 @@ TEST_F(FileSystemContextTest, NullExternalMountPoints) {
   std::string isolated_name = "root";
   std::string isolated_id =
       IsolatedContext::GetInstance()->RegisterFileSystemForPath(
-          fileapi::kFileSystemTypeNativeLocal,
+          storage::kFileSystemTypeNativeLocal,
           std::string(),
           base::FilePath(DRIVE FPL("/test/isolated/root")),
           &isolated_name);
   // Register system external mount point.
   ASSERT_TRUE(ExternalMountPoints::GetSystemInstance()->RegisterFileSystem(
       "system",
-      fileapi::kFileSystemTypeNativeLocal,
+      storage::kFileSystemTypeNativeLocal,
       FileSystemMountOption(),
       base::FilePath(DRIVE FPL("/test/sys/"))));
 
@@ -130,12 +130,13 @@ TEST_F(FileSystemContextTest, NullExternalMountPoints) {
   ExpectFileSystemURLMatches(
       cracked_isolated,
       GURL(kTestOrigin),
-      fileapi::kFileSystemTypeIsolated,
-      fileapi::kFileSystemTypeNativeLocal,
-      base::FilePath(
-          DRIVE FPL("/test/isolated/root/file")).NormalizePathSeparators(),
-      base::FilePath::FromUTF8Unsafe(isolated_id).Append(FPL("root/file")).
-          NormalizePathSeparators(),
+      storage::kFileSystemTypeIsolated,
+      storage::kFileSystemTypeNativeLocal,
+      base::FilePath(DRIVE FPL("/test/isolated/root/file"))
+          .NormalizePathSeparators(),
+      base::FilePath::FromUTF8Unsafe(isolated_id)
+          .Append(FPL("root/file"))
+          .NormalizePathSeparators(),
       isolated_id);
 
   FileSystemURL cracked_external = file_system_context->CrackURL(
@@ -144,14 +145,13 @@ TEST_F(FileSystemContextTest, NullExternalMountPoints) {
   ExpectFileSystemURLMatches(
       cracked_external,
       GURL(kTestOrigin),
-      fileapi::kFileSystemTypeExternal,
-      fileapi::kFileSystemTypeNativeLocal,
-      base::FilePath(
-          DRIVE FPL("/test/sys/root/file")).NormalizePathSeparators(),
+      storage::kFileSystemTypeExternal,
+      storage::kFileSystemTypeNativeLocal,
+      base::FilePath(DRIVE FPL("/test/sys/root/file"))
+          .NormalizePathSeparators(),
       base::FilePath(FPL("system/root/file")).NormalizePathSeparators(),
       "system");
 
-
   IsolatedContext::GetInstance()->RevokeFileSystem(isolated_id);
   ExternalMountPoints::GetSystemInstance()->RevokeFileSystem("system");
 }
@@ -164,7 +164,7 @@ TEST_F(FileSystemContextTest, FileSystemContextKeepsMountPointsAlive) {
   // Register system external mount point.
   ASSERT_TRUE(mount_points->RegisterFileSystem(
       "system",
-      fileapi::kFileSystemTypeNativeLocal,
+      storage::kFileSystemTypeNativeLocal,
       FileSystemMountOption(),
       base::FilePath(DRIVE FPL("/test/sys/"))));
 
@@ -182,10 +182,10 @@ TEST_F(FileSystemContextTest, FileSystemContextKeepsMountPointsAlive) {
   ExpectFileSystemURLMatches(
       cracked_external,
       GURL(kTestOrigin),
-      fileapi::kFileSystemTypeExternal,
-      fileapi::kFileSystemTypeNativeLocal,
-      base::FilePath(
-          DRIVE FPL("/test/sys/root/file")).NormalizePathSeparators(),
+      storage::kFileSystemTypeExternal,
+      storage::kFileSystemTypeNativeLocal,
+      base::FilePath(DRIVE FPL("/test/sys/root/file"))
+          .NormalizePathSeparators(),
       base::FilePath(FPL("system/root/file")).NormalizePathSeparators(),
       "system");
 
@@ -203,35 +203,35 @@ TEST_F(FileSystemContextTest, CrackFileSystemURL) {
   std::string isolated_file_system_name = "root";
   const std::string kIsolatedFileSystemID =
       IsolatedContext::GetInstance()->RegisterFileSystemForPath(
-          fileapi::kFileSystemTypeNativeLocal,
+          storage::kFileSystemTypeNativeLocal,
           std::string(),
           base::FilePath(DRIVE FPL("/test/isolated/root")),
           &isolated_file_system_name);
   // Register system external mount point.
   ASSERT_TRUE(ExternalMountPoints::GetSystemInstance()->RegisterFileSystem(
       "system",
-      fileapi::kFileSystemTypeDrive,
+      storage::kFileSystemTypeDrive,
       FileSystemMountOption(),
       base::FilePath(DRIVE FPL("/test/sys/"))));
   ASSERT_TRUE(ExternalMountPoints::GetSystemInstance()->RegisterFileSystem(
       "ext",
-      fileapi::kFileSystemTypeNativeLocal,
+      storage::kFileSystemTypeNativeLocal,
       FileSystemMountOption(),
       base::FilePath(DRIVE FPL("/test/ext"))));
   // Register a system external mount point with the same name/id as the
   // registered isolated mount point.
   ASSERT_TRUE(ExternalMountPoints::GetSystemInstance()->RegisterFileSystem(
       kIsolatedFileSystemID,
-      fileapi::kFileSystemTypeRestrictedNativeLocal,
+      storage::kFileSystemTypeRestrictedNativeLocal,
       FileSystemMountOption(),
       base::FilePath(DRIVE FPL("/test/system/isolated"))));
   // Add a mount points with the same name as a system mount point to
   // FileSystemContext's external mount points.
   ASSERT_TRUE(external_mount_points->RegisterFileSystem(
       "ext",
-       fileapi::kFileSystemTypeNativeLocal,
-       FileSystemMountOption(),
-       base::FilePath(DRIVE FPL("/test/local/ext/"))));
+      storage::kFileSystemTypeNativeLocal,
+      FileSystemMountOption(),
+      base::FilePath(DRIVE FPL("/test/local/ext/"))));
 
   const GURL kTestOrigin = GURL("http://chromium.org/");
   const base::FilePath kVirtualPathNoRoot = base::FilePath(FPL("root/file"));
@@ -243,8 +243,8 @@ TEST_F(FileSystemContextTest, CrackFileSystemURL) {
 
     // Expected test results.
     bool expect_is_valid;
-    fileapi::FileSystemType expect_mount_type;
-    fileapi::FileSystemType expect_type;
+    storage::FileSystemType expect_mount_type;
+    storage::FileSystemType expect_type;
     const base::FilePath::CharType* expect_path;
     std::string expect_filesystem_id;
   };
@@ -252,60 +252,42 @@ TEST_F(FileSystemContextTest, CrackFileSystemURL) {
   const TestCase kTestCases[] = {
       // Following should not be handled by the url crackers:
       {
-        "pers_mount", "persistent", true /* is_valid */,
-        fileapi::kFileSystemTypePersistent, fileapi::kFileSystemTypePersistent,
-        FPL("pers_mount/root/file"),
-        std::string()  /* filesystem id */
+       "pers_mount", "persistent", true /* is_valid */,
+       storage::kFileSystemTypePersistent, storage::kFileSystemTypePersistent,
+       FPL("pers_mount/root/file"), std::string() /* filesystem id */
       },
       {
-        "temp_mount", "temporary", true /* is_valid */,
-        fileapi::kFileSystemTypeTemporary, fileapi::kFileSystemTypeTemporary,
-        FPL("temp_mount/root/file"),
-        std::string()  /* filesystem id */
+       "temp_mount", "temporary", true /* is_valid */,
+       storage::kFileSystemTypeTemporary, storage::kFileSystemTypeTemporary,
+       FPL("temp_mount/root/file"), std::string() /* filesystem id */
       },
       // Should be cracked by isolated mount points:
-      {
-        kIsolatedFileSystemID, "isolated", true /* is_valid */,
-        fileapi::kFileSystemTypeIsolated, fileapi::kFileSystemTypeNativeLocal,
-        DRIVE FPL("/test/isolated/root/file"),
-        kIsolatedFileSystemID
-      },
+      {kIsolatedFileSystemID, "isolated", true /* is_valid */,
+       storage::kFileSystemTypeIsolated, storage::kFileSystemTypeNativeLocal,
+       DRIVE FPL("/test/isolated/root/file"), kIsolatedFileSystemID},
       // Should be cracked by system mount points:
-      {
-        "system", "external", true /* is_valid */,
-        fileapi::kFileSystemTypeExternal, fileapi::kFileSystemTypeDrive,
-        DRIVE FPL("/test/sys/root/file"),
-        "system"
-      },
-      {
-        kIsolatedFileSystemID, "external", true /* is_valid */,
-        fileapi::kFileSystemTypeExternal,
-        fileapi::kFileSystemTypeRestrictedNativeLocal,
-        DRIVE FPL("/test/system/isolated/root/file"),
-        kIsolatedFileSystemID
-      },
+      {"system", "external", true /* is_valid */,
+       storage::kFileSystemTypeExternal, storage::kFileSystemTypeDrive,
+       DRIVE FPL("/test/sys/root/file"), "system"},
+      {kIsolatedFileSystemID, "external", true /* is_valid */,
+       storage::kFileSystemTypeExternal,
+       storage::kFileSystemTypeRestrictedNativeLocal,
+       DRIVE FPL("/test/system/isolated/root/file"), kIsolatedFileSystemID},
       // Should be cracked by FileSystemContext's ExternalMountPoints.
-      {
-        "ext", "external", true /* is_valid */,
-        fileapi::kFileSystemTypeExternal, fileapi::kFileSystemTypeNativeLocal,
-        DRIVE FPL("/test/local/ext/root/file"),
-        "ext"
-      },
+      {"ext", "external", true /* is_valid */, storage::kFileSystemTypeExternal,
+       storage::kFileSystemTypeNativeLocal,
+       DRIVE FPL("/test/local/ext/root/file"), "ext"},
       // Test for invalid filesystem url (made invalid by adding invalid
       // filesystem type).
-      {
-        "sytem", "external", false /* is_valid */,
-        // The rest of values will be ignored.
-        fileapi::kFileSystemTypeUnknown, fileapi::kFileSystemTypeUnknown,
-        FPL(""), std::string()
-      },
+      {"sytem", "external", false /* is_valid */,
+       // The rest of values will be ignored.
+       storage::kFileSystemTypeUnknown, storage::kFileSystemTypeUnknown,
+       FPL(""), std::string()},
       // Test for URL with non-existing filesystem id.
-      {
-        "invalid", "external", false /* is_valid */,
-        // The rest of values will be ignored.
-        fileapi::kFileSystemTypeUnknown, fileapi::kFileSystemTypeUnknown,
-        FPL(""), std::string()
-      },
+      {"invalid", "external", false /* is_valid */,
+       // The rest of values will be ignored.
+       storage::kFileSystemTypeUnknown, storage::kFileSystemTypeUnknown,
+       FPL(""), std::string()},
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
@@ -351,31 +333,32 @@ TEST_F(FileSystemContextTest, CanServeURLRequest) {
   // A request for a sandbox mount point should be served.
   FileSystemURL cracked_url =
       context->CrackURL(CreateRawFileSystemURL("persistent", "pers_mount"));
-  EXPECT_EQ(fileapi::kFileSystemTypePersistent, cracked_url.mount_type());
+  EXPECT_EQ(storage::kFileSystemTypePersistent, cracked_url.mount_type());
   EXPECT_TRUE(context->CanServeURLRequest(cracked_url));
 
   // A request for an isolated mount point should NOT be served.
   std::string isolated_fs_name = "root";
   std::string isolated_fs_id =
       IsolatedContext::GetInstance()->RegisterFileSystemForPath(
-          fileapi::kFileSystemTypeNativeLocal,
+          storage::kFileSystemTypeNativeLocal,
           std::string(),
           base::FilePath(DRIVE FPL("/test/isolated/root")),
           &isolated_fs_name);
   cracked_url = context->CrackURL(
       CreateRawFileSystemURL("isolated", isolated_fs_id));
-  EXPECT_EQ(fileapi::kFileSystemTypeIsolated, cracked_url.mount_type());
+  EXPECT_EQ(storage::kFileSystemTypeIsolated, cracked_url.mount_type());
   EXPECT_FALSE(context->CanServeURLRequest(cracked_url));
 
   // A request for an external mount point should be served.
   const std::string kExternalMountName = "ext_mount";
   ASSERT_TRUE(ExternalMountPoints::GetSystemInstance()->RegisterFileSystem(
-      kExternalMountName, fileapi::kFileSystemTypeDrive,
+      kExternalMountName,
+      storage::kFileSystemTypeDrive,
       FileSystemMountOption(),
       base::FilePath()));
   cracked_url = context->CrackURL(
       CreateRawFileSystemURL("external", kExternalMountName));
-  EXPECT_EQ(fileapi::kFileSystemTypeExternal, cracked_url.mount_type());
+  EXPECT_EQ(storage::kFileSystemTypeExternal, cracked_url.mount_type());
   EXPECT_TRUE(context->CanServeURLRequest(cracked_url));
 
   ExternalMountPoints::GetSystemInstance()->RevokeFileSystem(
diff --git a/content/browser/fileapi/file_system_dir_url_request_job_unittest.cc b/content/browser/fileapi/file_system_dir_url_request_job_unittest.cc
index 8741cff..02b886d 100644
--- a/content/browser/fileapi/file_system_dir_url_request_job_unittest.cc
+++ b/content/browser/fileapi/file_system_dir_url_request_job_unittest.cc
@@ -34,9 +34,9 @@
 #include "webkit/browser/fileapi/file_system_operation_context.h"
 #include "webkit/browser/fileapi/file_system_url.h"
 
-using fileapi::FileSystemContext;
-using fileapi::FileSystemOperationContext;
-using fileapi::FileSystemURL;
+using storage::FileSystemContext;
+using storage::FileSystemOperationContext;
+using storage::FileSystemURL;
 
 namespace content {
 namespace {
@@ -50,7 +50,7 @@ const char kValidExternalMountPoint[] = "mnt_name";
 // "automount", but will only succeed for the mount point "mnt_name".
 bool TestAutoMountForURLRequest(
     const net::URLRequest* /*url_request*/,
-    const fileapi::FileSystemURL& filesystem_url,
+    const storage::FileSystemURL& filesystem_url,
     const std::string& storage_domain,
     const base::Callback<void(base::File::Error result)>& callback) {
   if (storage_domain != "automount")
@@ -61,9 +61,11 @@ bool TestAutoMountForURLRequest(
   std::string mount_point = base::FilePath(components[0]).AsUTF8Unsafe();
 
   if (mount_point == kValidExternalMountPoint) {
-    fileapi::ExternalMountPoints::GetSystemInstance()->RegisterFileSystem(
-        kValidExternalMountPoint, fileapi::kFileSystemTypeTest,
-        fileapi::FileSystemMountOption(), base::FilePath());
+    storage::ExternalMountPoints::GetSystemInstance()->RegisterFileSystem(
+        kValidExternalMountPoint,
+        storage::kFileSystemTypeTest,
+        storage::FileSystemMountOption(),
+        base::FilePath());
     callback.Run(base::File::FILE_OK);
   } else {
     callback.Run(base::File::FILE_ERROR_NOT_FOUND);
@@ -82,7 +84,7 @@ class FileSystemDirURLRequestJobFactory : public net::URLRequestJobFactory {
       const std::string& scheme,
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const OVERRIDE {
-    return new fileapi::FileSystemDirURLRequestJob(
+    return new storage::FileSystemDirURLRequestJob(
         request, network_delegate, storage_domain_, file_system_context_);
   }
 
@@ -120,8 +122,9 @@ class FileSystemDirURLRequestJobTest : public testing::Test {
         NULL, temp_dir_.path());
 
     file_system_context_->OpenFileSystem(
-        GURL("http://remote/"), fileapi::kFileSystemTypeTemporary,
-        fileapi::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
+        GURL("http://remote/"),
+        storage::kFileSystemTypeTemporary,
+        storage::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
         base::Bind(&FileSystemDirURLRequestJobTest::OnOpenFileSystem,
                    weak_factory_.GetWeakPtr()));
     base::RunLoop().RunUntilIdle();
@@ -137,11 +140,11 @@ class FileSystemDirURLRequestJobTest : public testing::Test {
     *mnt_point = temp_dir_.path().AppendASCII("auto_mount_dir");
     ASSERT_TRUE(base::CreateDirectory(*mnt_point));
 
-    ScopedVector<fileapi::FileSystemBackend> additional_providers;
+    ScopedVector<storage::FileSystemBackend> additional_providers;
     additional_providers.push_back(new TestFileSystemBackend(
         base::MessageLoopProxy::current().get(), *mnt_point));
 
-    std::vector<fileapi::URLRequestAutoMountHandler> handlers;
+    std::vector<storage::URLRequestAutoMountHandler> handlers;
     handlers.push_back(base::Bind(&TestAutoMountForURLRequest));
 
     file_system_context_ = CreateFileSystemContextWithAutoMountersForTesting(
@@ -185,9 +188,7 @@ class FileSystemDirURLRequestJobTest : public testing::Test {
 
   FileSystemURL CreateURL(const base::FilePath& file_path) {
     return file_system_context_->CreateCrackedFileSystemURL(
-        GURL("http://remote"),
-        fileapi::kFileSystemTypeTemporary,
-        file_path);
+        GURL("http://remote"), storage::kFileSystemTypeTemporary, file_path);
   }
 
   FileSystemOperationContext* NewOperationContext() {
@@ -268,7 +269,7 @@ class FileSystemDirURLRequestJobTest : public testing::Test {
     return GURL(kFileSystemURLPrefix + path);
   }
 
-  fileapi::FileSystemFileUtil* file_util() {
+  storage::FileSystemFileUtil* file_util() {
     return file_system_context_->sandbox_delegate()->sync_file_util();
   }
 
@@ -406,7 +407,7 @@ TEST_F(FileSystemDirURLRequestJobTest, AutoMountDirectoryListing) {
   VerifyListingEntry(listing_entries[1], "foo", "foo", true, -1);
 
   ASSERT_TRUE(
-      fileapi::ExternalMountPoints::GetSystemInstance()->RevokeFileSystem(
+      storage::ExternalMountPoints::GetSystemInstance()->RevokeFileSystem(
           kValidExternalMountPoint));
 }
 
@@ -420,7 +421,7 @@ TEST_F(FileSystemDirURLRequestJobTest, AutoMountInvalidRoot) {
   EXPECT_EQ(net::ERR_FILE_NOT_FOUND, request_->status().error());
 
   ASSERT_FALSE(
-      fileapi::ExternalMountPoints::GetSystemInstance()->RevokeFileSystem(
+      storage::ExternalMountPoints::GetSystemInstance()->RevokeFileSystem(
           "invalid"));
 }
 
@@ -434,7 +435,7 @@ TEST_F(FileSystemDirURLRequestJobTest, AutoMountNoHandler) {
   EXPECT_EQ(net::ERR_FILE_NOT_FOUND, request_->status().error());
 
   ASSERT_FALSE(
-      fileapi::ExternalMountPoints::GetSystemInstance()->RevokeFileSystem(
+      storage::ExternalMountPoints::GetSystemInstance()->RevokeFileSystem(
           kValidExternalMountPoint));
 }
 
diff --git a/content/browser/fileapi/file_system_file_stream_reader_unittest.cc b/content/browser/fileapi/file_system_file_stream_reader_unittest.cc
index fe1d25e5..610fe78 100644
--- a/content/browser/fileapi/file_system_file_stream_reader_unittest.cc
+++ b/content/browser/fileapi/file_system_file_stream_reader_unittest.cc
@@ -21,10 +21,10 @@
 #include "webkit/browser/fileapi/file_system_file_util.h"
 
 using content::AsyncFileTestHelper;
-using fileapi::FileSystemContext;
-using fileapi::FileSystemFileStreamReader;
-using fileapi::FileSystemType;
-using fileapi::FileSystemURL;
+using storage::FileSystemContext;
+using storage::FileSystemFileStreamReader;
+using storage::FileSystemType;
+using storage::FileSystemURL;
 
 namespace content {
 
@@ -35,7 +35,7 @@ const char kTestFileName[] = "test.dat";
 const char kTestData[] = "0123456789";
 const int kTestDataSize = arraysize(kTestData) - 1;
 
-void ReadFromReader(fileapi::FileSystemFileStreamReader* reader,
+void ReadFromReader(storage::FileSystemFileStreamReader* reader,
                     std::string* data,
                     size_t size,
                     int* result) {
@@ -74,8 +74,9 @@ class FileSystemFileStreamReaderTest : public testing::Test {
         NULL, temp_dir_.path());
 
     file_system_context_->OpenFileSystem(
-        GURL(kURLOrigin), fileapi::kFileSystemTypeTemporary,
-        fileapi::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
+        GURL(kURLOrigin),
+        storage::kFileSystemTypeTemporary,
+        storage::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
         base::Bind(&OnOpenFileSystem));
     base::RunLoop().RunUntilIdle();
 
@@ -88,7 +89,7 @@ class FileSystemFileStreamReaderTest : public testing::Test {
   }
 
  protected:
-  fileapi::FileSystemFileStreamReader* CreateFileReader(
+  storage::FileSystemFileStreamReader* CreateFileReader(
       const std::string& file_name,
       int64 initial_offset,
       const base::Time& expected_modification_time) {
@@ -130,7 +131,7 @@ class FileSystemFileStreamReaderTest : public testing::Test {
   FileSystemURL GetFileSystemURL(const std::string& file_name) {
     return file_system_context_->CreateCrackedFileSystemURL(
         GURL(kURLOrigin),
-        fileapi::kFileSystemTypeTemporary,
+        storage::kFileSystemTypeTemporary,
         base::FilePath().AppendASCII(file_name));
   }
 
diff --git a/content/browser/fileapi/file_system_operation_impl_unittest.cc b/content/browser/fileapi/file_system_operation_impl_unittest.cc
index 2f8e82e..afbe664 100644
--- a/content/browser/fileapi/file_system_operation_impl_unittest.cc
+++ b/content/browser/fileapi/file_system_operation_impl_unittest.cc
@@ -30,13 +30,13 @@
 #include "webkit/common/fileapi/file_system_util.h"
 
 using content::AsyncFileTestHelper;
-using fileapi::FileSystemOperation;
-using fileapi::FileSystemOperationContext;
-using fileapi::FileSystemOperationRunner;
-using fileapi::FileSystemURL;
-using quota::QuotaManager;
-using quota::QuotaManagerProxy;
-using webkit_blob::ShareableFileReference;
+using storage::FileSystemOperation;
+using storage::FileSystemOperationContext;
+using storage::FileSystemOperationRunner;
+using storage::FileSystemURL;
+using storage::QuotaManager;
+using storage::QuotaManagerProxy;
+using storage::ShareableFileReference;
 
 namespace content {
 
@@ -63,8 +63,8 @@ class FileSystemOperationImplTest
  protected:
   virtual void SetUp() OVERRIDE {
     EXPECT_TRUE(base_.CreateUniqueTempDir());
-    change_observers_ = fileapi::MockFileChangeObserver::CreateList(
-        &change_observer_);
+    change_observers_ =
+        storage::MockFileChangeObserver::CreateList(&change_observer_);
 
     base::FilePath base_dir = base_.path().AppendASCII("filesystem");
     quota_manager_ =
@@ -94,7 +94,7 @@ class FileSystemOperationImplTest
   int status() const { return status_; }
   const base::File::Info& info() const { return info_; }
   const base::FilePath& path() const { return path_; }
-  const std::vector<fileapi::DirectoryEntry>& entries() const {
+  const std::vector<storage::DirectoryEntry>& entries() const {
     return entries_;
   }
 
@@ -111,11 +111,11 @@ class FileSystemOperationImplTest
         quota_manager_proxy_.get());
   }
 
-  fileapi::FileSystemFileUtil* file_util() {
+  storage::FileSystemFileUtil* file_util() {
     return sandbox_file_system_.file_util();
   }
 
-  fileapi::MockFileChangeObserver* change_observer() {
+  storage::MockFileChangeObserver* change_observer() {
     return &change_observer_;
   }
 
@@ -197,10 +197,9 @@ class FileSystemOperationImplTest
     status_ = status;
   }
 
-  void DidReadDirectory(
-      base::File::Error status,
-      const std::vector<fileapi::DirectoryEntry>& entries,
-      bool /* has_more */) {
+  void DidReadDirectory(base::File::Error status,
+                        const std::vector<storage::DirectoryEntry>& entries,
+                        bool /* has_more */) {
     entries_ = entries;
     status_ = status;
   }
@@ -228,14 +227,14 @@ class FileSystemOperationImplTest
   }
 
   void GetUsageAndQuota(int64* usage, int64* quota) {
-    quota::QuotaStatusCode status =
+    storage::QuotaStatusCode status =
         AsyncFileTestHelper::GetUsageAndQuota(quota_manager_.get(),
                                               sandbox_file_system_.origin(),
                                               sandbox_file_system_.type(),
                                               usage,
                                               quota);
     base::RunLoop().RunUntilIdle();
-    ASSERT_EQ(quota::kQuotaStatusOk, status);
+    ASSERT_EQ(storage::kQuotaStatusOk, status);
   }
 
   int64 ComputePathCost(const FileSystemURL& url) {
@@ -291,11 +290,11 @@ class FileSystemOperationImplTest
   int status_;
   base::File::Info info_;
   base::FilePath path_;
-  std::vector<fileapi::DirectoryEntry> entries_;
+  std::vector<storage::DirectoryEntry> entries_;
   scoped_refptr<ShareableFileReference> shareable_file_ref_;
 
-  fileapi::MockFileChangeObserver change_observer_;
-  fileapi::ChangeObserverList change_observers_;
+  storage::MockFileChangeObserver change_observer_;
+  storage::ChangeObserverList change_observers_;
 
   base::WeakPtrFactory<FileSystemOperationImplTest> weak_factory_;
 
diff --git a/content/browser/fileapi/file_system_operation_impl_write_unittest.cc b/content/browser/fileapi/file_system_operation_impl_write_unittest.cc
index 47b0e2d..899bb5f9 100644
--- a/content/browser/fileapi/file_system_operation_impl_write_unittest.cc
+++ b/content/browser/fileapi/file_system_operation_impl_write_unittest.cc
@@ -30,9 +30,9 @@
 #include "webkit/common/blob/blob_data.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
-using fileapi::FileSystemOperation;
-using fileapi::FileSystemOperationRunner;
-using fileapi::FileSystemURL;
+using storage::FileSystemOperation;
+using storage::FileSystemOperationRunner;
+using storage::FileSystemURL;
 using content::MockBlobURLRequestContext;
 using content::ScopedTextBlob;
 
@@ -41,7 +41,7 @@ namespace content {
 namespace {
 
 const GURL kOrigin("http://example.com");
-const fileapi::FileSystemType kFileSystemType = fileapi::kFileSystemTypeTest;
+const storage::FileSystemType kFileSystemType = storage::kFileSystemTypeTest;
 
 void AssertStatusEq(base::File::Error expected,
                     base::File::Error actual) {
@@ -59,8 +59,8 @@ class FileSystemOperationImplWriteTest
         bytes_written_(0),
         complete_(false),
         weak_factory_(this) {
-    change_observers_ = fileapi::MockFileChangeObserver::CreateList(
-        &change_observer_);
+    change_observers_ =
+        storage::MockFileChangeObserver::CreateList(&change_observer_);
   }
 
   virtual void SetUp() {
@@ -105,11 +105,11 @@ class FileSystemOperationImplWriteTest
   bool complete() const { return complete_; }
 
  protected:
-  const fileapi::ChangeObserverList& change_observers() const {
+  const storage::ChangeObserverList& change_observers() const {
     return change_observers_;
   }
 
-  fileapi::MockFileChangeObserver* change_observer() {
+  storage::MockFileChangeObserver* change_observer() {
     return &change_observer_;
   }
 
@@ -152,7 +152,7 @@ class FileSystemOperationImplWriteTest
     return *url_request_context_;
   }
 
-  scoped_refptr<fileapi::FileSystemContext> file_system_context_;
+  scoped_refptr<storage::FileSystemContext> file_system_context_;
   scoped_refptr<MockQuotaManager> quota_manager_;
 
   base::MessageLoopForIO loop_;
@@ -168,8 +168,8 @@ class FileSystemOperationImplWriteTest
 
   scoped_ptr<MockBlobURLRequestContext> url_request_context_;
 
-  fileapi::MockFileChangeObserver change_observer_;
-  fileapi::ChangeObserverList change_observers_;
+  storage::MockFileChangeObserver change_observer_;
+  storage::ChangeObserverList change_observers_;
 
   base::WeakPtrFactory<FileSystemOperationImplWriteTest> weak_factory_;
 
@@ -209,7 +209,7 @@ TEST_F(FileSystemOperationImplWriteTest, TestWriteZero) {
 
 
 TEST_F(FileSystemOperationImplWriteTest, TestWriteInvalidBlobUrl) {
-  scoped_ptr<webkit_blob::BlobDataHandle> null_handle;
+  scoped_ptr<storage::BlobDataHandle> null_handle;
   file_system_context_->operation_runner()->Write(
       &url_request_context(), URLForPath(virtual_path_),
       null_handle.Pass(), 0, RecordWriteCallback());
diff --git a/content/browser/fileapi/file_system_operation_runner_unittest.cc b/content/browser/fileapi/file_system_operation_runner_unittest.cc
index af5f8e7..3aea200 100644
--- a/content/browser/fileapi/file_system_operation_runner_unittest.cc
+++ b/content/browser/fileapi/file_system_operation_runner_unittest.cc
@@ -11,10 +11,10 @@
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_operation_runner.h"
 
-using fileapi::FileSystemContext;
-using fileapi::FileSystemOperationRunner;
-using fileapi::FileSystemType;
-using fileapi::FileSystemURL;
+using storage::FileSystemContext;
+using storage::FileSystemOperationRunner;
+using storage::FileSystemType;
+using storage::FileSystemURL;
 
 namespace content {
 
@@ -56,7 +56,8 @@ class FileSystemOperationRunnerTest : public testing::Test {
 
   FileSystemURL URL(const std::string& path) {
     return file_system_context_->CreateCrackedFileSystemURL(
-        GURL("http://example.com"), fileapi::kFileSystemTypeTemporary,
+        GURL("http://example.com"),
+        storage::kFileSystemTypeTemporary,
         base::FilePath::FromUTF8Unsafe(path));
   }
 
diff --git a/content/browser/fileapi/file_system_quota_client_unittest.cc b/content/browser/fileapi/file_system_quota_client_unittest.cc
index 65eaf57..7785184 100644
--- a/content/browser/fileapi/file_system_quota_client_unittest.cc
+++ b/content/browser/fileapi/file_system_quota_client_unittest.cc
@@ -21,8 +21,8 @@
 #include "webkit/common/quota/quota_types.h"
 
 using content::AsyncFileTestHelper;
-using fileapi::FileSystemQuotaClient;
-using fileapi::FileSystemURL;
+using storage::FileSystemQuotaClient;
+using storage::FileSystemURL;
 
 namespace content {
 namespace {
@@ -32,8 +32,8 @@ const char kDummyURL2[] = "http://www.example.com";
 const char kDummyURL3[] = "http://www.bleh";
 
 // Declared to shorten the variable names.
-const quota::StorageType kTemporary = quota::kStorageTypeTemporary;
-const quota::StorageType kPersistent = quota::kStorageTypePersistent;
+const storage::StorageType kTemporary = storage::kStorageTypeTemporary;
+const storage::StorageType kPersistent = storage::kStorageTypePersistent;
 
 }  // namespace
 
@@ -42,8 +42,7 @@ class FileSystemQuotaClientTest : public testing::Test {
   FileSystemQuotaClientTest()
       : weak_factory_(this),
         additional_callback_count_(0),
-        deletion_status_(quota::kQuotaStatusUnknown) {
-  }
+        deletion_status_(storage::kQuotaStatusUnknown) {}
 
   virtual void SetUp() {
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
@@ -56,7 +55,7 @@ class FileSystemQuotaClientTest : public testing::Test {
     const char* name;
     int64 size;
     const char* origin_url;
-    quota::StorageType type;
+    storage::StorageType type;
   };
 
  protected:
@@ -66,7 +65,7 @@ class FileSystemQuotaClientTest : public testing::Test {
 
   void GetOriginUsageAsync(FileSystemQuotaClient* quota_client,
                            const std::string& origin_url,
-                           quota::StorageType type) {
+                           storage::StorageType type) {
     quota_client->GetOriginUsage(
         GURL(origin_url), type,
         base::Bind(&FileSystemQuotaClientTest::OnGetUsage,
@@ -75,15 +74,14 @@ class FileSystemQuotaClientTest : public testing::Test {
 
   int64 GetOriginUsage(FileSystemQuotaClient* quota_client,
                        const std::string& origin_url,
-                       quota::StorageType type) {
+                       storage::StorageType type) {
     GetOriginUsageAsync(quota_client, origin_url, type);
     base::RunLoop().RunUntilIdle();
     return usage_;
   }
 
-  const std::set<GURL>& GetOriginsForType(
-      FileSystemQuotaClient* quota_client,
-      quota::StorageType type) {
+  const std::set<GURL>& GetOriginsForType(FileSystemQuotaClient* quota_client,
+                                          storage::StorageType type) {
     origins_.clear();
     quota_client->GetOriginsForType(
         type,
@@ -93,10 +91,9 @@ class FileSystemQuotaClientTest : public testing::Test {
     return origins_;
   }
 
-  const std::set<GURL>& GetOriginsForHost(
-      FileSystemQuotaClient* quota_client,
-      quota::StorageType type,
-      const std::string& host) {
+  const std::set<GURL>& GetOriginsForHost(FileSystemQuotaClient* quota_client,
+                                          storage::StorageType type,
+                                          const std::string& host) {
     origins_.clear();
     quota_client->GetOriginsForHost(
         type, host,
@@ -106,10 +103,9 @@ class FileSystemQuotaClientTest : public testing::Test {
     return origins_;
   }
 
-  void RunAdditionalOriginUsageTask(
-      FileSystemQuotaClient* quota_client,
-      const std::string& origin_url,
-      quota::StorageType type) {
+  void RunAdditionalOriginUsageTask(FileSystemQuotaClient* quota_client,
+                                    const std::string& origin_url,
+                                    storage::StorageType type) {
     quota_client->GetOriginUsage(
         GURL(origin_url), type,
         base::Bind(&FileSystemQuotaClientTest::OnGetAdditionalUsage,
@@ -118,9 +114,9 @@ class FileSystemQuotaClientTest : public testing::Test {
 
   bool CreateFileSystemDirectory(const base::FilePath& file_path,
                                  const std::string& origin_url,
-                                 quota::StorageType storage_type) {
-    fileapi::FileSystemType type =
-        fileapi::QuotaStorageTypeToFileSystemType(storage_type);
+                                 storage::StorageType storage_type) {
+    storage::FileSystemType type =
+        storage::QuotaStorageTypeToFileSystemType(storage_type);
     FileSystemURL url = file_system_context_->CreateCrackedFileSystemURL(
         GURL(origin_url), type, file_path);
 
@@ -132,12 +128,12 @@ class FileSystemQuotaClientTest : public testing::Test {
   bool CreateFileSystemFile(const base::FilePath& file_path,
                             int64 file_size,
                             const std::string& origin_url,
-                            quota::StorageType storage_type) {
+                            storage::StorageType storage_type) {
     if (file_path.empty())
       return false;
 
-    fileapi::FileSystemType type =
-        fileapi::QuotaStorageTypeToFileSystemType(storage_type);
+    storage::FileSystemType type =
+        storage::QuotaStorageTypeToFileSystemType(storage_type);
     FileSystemURL url = file_system_context_->CreateCrackedFileSystemURL(
         GURL(origin_url), type, file_path);
 
@@ -182,15 +178,15 @@ class FileSystemQuotaClientTest : public testing::Test {
   int64 ComputeFilePathsCostForOriginAndType(const TestFile* files,
                                              int num_files,
                                              const std::string& origin_url,
-                                             quota::StorageType type) {
+                                             storage::StorageType type) {
     int64 file_paths_cost = 0;
     for (int i = 0; i < num_files; i++) {
       if (files[i].type == type &&
           GURL(files[i].origin_url) == GURL(origin_url)) {
         base::FilePath path = base::FilePath().AppendASCII(files[i].name);
         if (!path.empty()) {
-          file_paths_cost += fileapi::ObfuscatedFileUtil::ComputeFilePathCost(
-              path);
+          file_paths_cost +=
+              storage::ObfuscatedFileUtil::ComputeFilePathCost(path);
         }
       }
     }
@@ -199,8 +195,8 @@ class FileSystemQuotaClientTest : public testing::Test {
 
   void DeleteOriginData(FileSystemQuotaClient* quota_client,
                         const std::string& origin,
-                        quota::StorageType type) {
-    deletion_status_ = quota::kQuotaStatusUnknown;
+                        storage::StorageType type) {
+    deletion_status_ = storage::kQuotaStatusUnknown;
     quota_client->DeleteOriginData(
         GURL(origin), type,
         base::Bind(&FileSystemQuotaClientTest::OnDeleteOrigin,
@@ -208,7 +204,7 @@ class FileSystemQuotaClientTest : public testing::Test {
   }
 
   int64 usage() const { return usage_; }
-  quota::QuotaStatusCode status() { return deletion_status_; }
+  storage::QuotaStatusCode status() { return deletion_status_; }
   int additional_callback_count() const { return additional_callback_count_; }
   void set_additional_callback_count(int count) {
     additional_callback_count_ = count;
@@ -227,18 +223,18 @@ class FileSystemQuotaClientTest : public testing::Test {
     ++additional_callback_count_;
   }
 
-  void OnDeleteOrigin(quota::QuotaStatusCode status) {
+  void OnDeleteOrigin(storage::QuotaStatusCode status) {
     deletion_status_ = status;
   }
 
   base::ScopedTempDir data_dir_;
   base::MessageLoop message_loop_;
-  scoped_refptr<fileapi::FileSystemContext> file_system_context_;
+  scoped_refptr<storage::FileSystemContext> file_system_context_;
   base::WeakPtrFactory<FileSystemQuotaClientTest> weak_factory_;
   int64 usage_;
   int additional_callback_count_;
   std::set<GURL> origins_;
-  quota::QuotaStatusCode deletion_status_;
+  storage::QuotaStatusCode deletion_status_;
 
   DISALLOW_COPY_AND_ASSIGN(FileSystemQuotaClientTest);
 };
@@ -528,15 +524,15 @@ TEST_F(FileSystemQuotaClientTest, DeleteOriginTest) {
 
   DeleteOriginData(quota_client.get(), "http://foo.com/", kTemporary);
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(quota::kQuotaStatusOk, status());
+  EXPECT_EQ(storage::kQuotaStatusOk, status());
 
   DeleteOriginData(quota_client.get(), "http://bar.com/", kPersistent);
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(quota::kQuotaStatusOk, status());
+  EXPECT_EQ(storage::kQuotaStatusOk, status());
 
   DeleteOriginData(quota_client.get(), "http://buz.com/", kTemporary);
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(quota::kQuotaStatusOk, status());
+  EXPECT_EQ(storage::kQuotaStatusOk, status());
 
   EXPECT_EQ(0, GetOriginUsage(
       quota_client.get(), "http://foo.com/", kTemporary));
diff --git a/content/browser/fileapi/file_system_url_request_job_unittest.cc b/content/browser/fileapi/file_system_url_request_job_unittest.cc
index 4f3d0ab..177f943 100644
--- a/content/browser/fileapi/file_system_url_request_job_unittest.cc
+++ b/content/browser/fileapi/file_system_url_request_job_unittest.cc
@@ -39,9 +39,9 @@
 #include "webkit/browser/fileapi/file_system_file_util.h"
 
 using content::AsyncFileTestHelper;
-using fileapi::FileSystemContext;
-using fileapi::FileSystemURL;
-using fileapi::FileSystemURLRequestJob;
+using storage::FileSystemContext;
+using storage::FileSystemURL;
+using storage::FileSystemURLRequestJob;
 
 namespace content {
 namespace {
@@ -60,7 +60,7 @@ const char kValidExternalMountPoint[] = "mnt_name";
 // "automount", but will only succeed for the mount point "mnt_name".
 bool TestAutoMountForURLRequest(
     const net::URLRequest* /*url_request*/,
-    const fileapi::FileSystemURL& filesystem_url,
+    const storage::FileSystemURL& filesystem_url,
     const std::string& storage_domain,
     const base::Callback<void(base::File::Error result)>& callback) {
   if (storage_domain != "automount")
@@ -70,9 +70,11 @@ bool TestAutoMountForURLRequest(
   std::string mount_point = base::FilePath(components[0]).AsUTF8Unsafe();
 
   if (mount_point == kValidExternalMountPoint) {
-    fileapi::ExternalMountPoints::GetSystemInstance()->RegisterFileSystem(
-        kValidExternalMountPoint, fileapi::kFileSystemTypeTest,
-        fileapi::FileSystemMountOption(), base::FilePath());
+    storage::ExternalMountPoints::GetSystemInstance()->RegisterFileSystem(
+        kValidExternalMountPoint,
+        storage::kFileSystemTypeTest,
+        storage::FileSystemMountOption(),
+        base::FilePath());
     callback.Run(base::File::FILE_OK);
   } else {
     callback.Run(base::File::FILE_ERROR_NOT_FOUND);
@@ -91,7 +93,7 @@ class FileSystemURLRequestJobFactory : public net::URLRequestJobFactory {
       const std::string& scheme,
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const OVERRIDE {
-    return new fileapi::FileSystemURLRequestJob(
+    return new storage::FileSystemURLRequestJob(
         request, network_delegate, storage_domain_, file_system_context_);
   }
 
@@ -128,8 +130,9 @@ class FileSystemURLRequestJobTest : public testing::Test {
         CreateFileSystemContextForTesting(NULL, temp_dir_.path());
 
     file_system_context_->OpenFileSystem(
-        GURL("http://remote/"), fileapi::kFileSystemTypeTemporary,
-        fileapi::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
+        GURL("http://remote/"),
+        storage::kFileSystemTypeTemporary,
+        storage::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
         base::Bind(&FileSystemURLRequestJobTest::OnOpenFileSystem,
                    weak_factory_.GetWeakPtr()));
     base::RunLoop().RunUntilIdle();
@@ -144,11 +147,11 @@ class FileSystemURLRequestJobTest : public testing::Test {
     base::FilePath mnt_point = temp_dir_.path().AppendASCII("auto_mount_dir");
     ASSERT_TRUE(base::CreateDirectory(mnt_point));
 
-    ScopedVector<fileapi::FileSystemBackend> additional_providers;
+    ScopedVector<storage::FileSystemBackend> additional_providers;
     additional_providers.push_back(new TestFileSystemBackend(
         base::MessageLoopProxy::current().get(), mnt_point));
 
-    std::vector<fileapi::URLRequestAutoMountHandler> handlers;
+    std::vector<storage::URLRequestAutoMountHandler> handlers;
     handlers.push_back(base::Bind(&TestAutoMountForURLRequest));
 
     file_system_context_ = CreateFileSystemContextWithAutoMountersForTesting(
@@ -210,7 +213,7 @@ class FileSystemURLRequestJobTest : public testing::Test {
   void CreateDirectory(const base::StringPiece& dir_name) {
     FileSystemURL url = file_system_context_->CreateCrackedFileSystemURL(
         GURL("http://remote"),
-        fileapi::kFileSystemTypeTemporary,
+        storage::kFileSystemTypeTemporary,
         base::FilePath().AppendASCII(dir_name));
     ASSERT_EQ(base::File::FILE_OK, AsyncFileTestHelper::CreateDirectory(
         file_system_context_, url));
@@ -220,7 +223,7 @@ class FileSystemURLRequestJobTest : public testing::Test {
                  const char* buf, int buf_size) {
     FileSystemURL url = file_system_context_->CreateCrackedFileSystemURL(
         GURL("http://remote"),
-        fileapi::kFileSystemTypeTemporary,
+        storage::kFileSystemTypeTemporary,
         base::FilePath().AppendASCII(file_name));
     ASSERT_EQ(base::File::FILE_OK,
               AsyncFileTestHelper::CreateFileWithData(
@@ -235,7 +238,7 @@ class FileSystemURLRequestJobTest : public testing::Test {
   base::MessageLoopForIO message_loop_;
 
   base::ScopedTempDir temp_dir_;
-  scoped_refptr<fileapi::FileSystemContext> file_system_context_;
+  scoped_refptr<storage::FileSystemContext> file_system_context_;
   base::WeakPtrFactory<FileSystemURLRequestJobTest> weak_factory_;
 
   net::URLRequestContext empty_context_;
@@ -430,7 +433,7 @@ TEST_F(FileSystemURLRequestJobTest, AutoMountFileTest) {
   EXPECT_EQ("no-cache", cache_control);
 
   ASSERT_TRUE(
-      fileapi::ExternalMountPoints::GetSystemInstance()->RevokeFileSystem(
+      storage::ExternalMountPoints::GetSystemInstance()->RevokeFileSystem(
           kValidExternalMountPoint));
 }
 
@@ -443,7 +446,7 @@ TEST_F(FileSystemURLRequestJobTest, AutoMountInvalidRoot) {
   EXPECT_EQ(net::ERR_FILE_NOT_FOUND, request_->status().error());
 
   ASSERT_FALSE(
-      fileapi::ExternalMountPoints::GetSystemInstance()->RevokeFileSystem(
+      storage::ExternalMountPoints::GetSystemInstance()->RevokeFileSystem(
           "invalid"));
 }
 
@@ -456,7 +459,7 @@ TEST_F(FileSystemURLRequestJobTest, AutoMountNoHandler) {
   EXPECT_EQ(net::ERR_FILE_NOT_FOUND, request_->status().error());
 
   ASSERT_FALSE(
-      fileapi::ExternalMountPoints::GetSystemInstance()->RevokeFileSystem(
+      storage::ExternalMountPoints::GetSystemInstance()->RevokeFileSystem(
           kValidExternalMountPoint));
 }
 
diff --git a/content/browser/fileapi/file_system_url_unittest.cc b/content/browser/fileapi/file_system_url_unittest.cc
index 4aa23dd..8167cbb 100644
--- a/content/browser/fileapi/file_system_url_unittest.cc
+++ b/content/browser/fileapi/file_system_url_unittest.cc
@@ -18,12 +18,12 @@
 #define DRIVE FPL("/a/")
 #endif
 
-using fileapi::FileSystemURL;
-using fileapi::kFileSystemTypeExternal;
-using fileapi::kFileSystemTypeIsolated;
-using fileapi::kFileSystemTypePersistent;
-using fileapi::kFileSystemTypeTemporary;
-using fileapi::VirtualPath;
+using storage::FileSystemURL;
+using storage::kFileSystemTypeExternal;
+using storage::kFileSystemTypeIsolated;
+using storage::kFileSystemTypePersistent;
+using storage::kFileSystemTypeTemporary;
+using storage::VirtualPath;
 
 namespace content {
 
diff --git a/content/browser/fileapi/file_system_usage_cache_unittest.cc b/content/browser/fileapi/file_system_usage_cache_unittest.cc
index 0a54b89..da2b19e 100644
--- a/content/browser/fileapi/file_system_usage_cache_unittest.cc
+++ b/content/browser/fileapi/file_system_usage_cache_unittest.cc
@@ -10,7 +10,7 @@
 #include "base/message_loop/message_loop.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using fileapi::FileSystemUsageCache;
+using storage::FileSystemUsageCache;
 
 namespace content {
 
diff --git a/content/browser/fileapi/file_writer_delegate_unittest.cc b/content/browser/fileapi/file_writer_delegate_unittest.cc
index ccbc4a5..d49f83b 100644
--- a/content/browser/fileapi/file_writer_delegate_unittest.cc
+++ b/content/browser/fileapi/file_writer_delegate_unittest.cc
@@ -28,15 +28,15 @@
 #include "webkit/browser/fileapi/sandbox_file_stream_writer.h"
 
 using content::AsyncFileTestHelper;
-using fileapi::FileSystemURL;
-using fileapi::FileWriterDelegate;
+using storage::FileSystemURL;
+using storage::FileWriterDelegate;
 
 namespace content {
 
 namespace {
 
 const GURL kOrigin("http://example.com");
-const fileapi::FileSystemType kFileSystemType = fileapi::kFileSystemTypeTest;
+const storage::FileSystemType kFileSystemType = storage::kFileSystemTypeTest;
 
 const char kData[] = "The quick brown fox jumps over the lazy dog.\n";
 const int kDataSize = ARRAYSIZE_UNSAFE(kData) - 1;
@@ -116,16 +116,15 @@ class FileWriterDelegateTest : public PlatformTest {
       const char* test_file_path,
       int64 offset,
       int64 allowed_growth) {
-    fileapi::SandboxFileStreamWriter* writer =
-        new fileapi::SandboxFileStreamWriter(
+    storage::SandboxFileStreamWriter* writer =
+        new storage::SandboxFileStreamWriter(
             file_system_context_.get(),
             GetFileSystemURL(test_file_path),
             offset,
             *file_system_context_->GetUpdateObservers(kFileSystemType));
     writer->set_default_quota(allowed_growth);
-    return new FileWriterDelegate(
-        scoped_ptr<fileapi::FileStreamWriter>(writer),
-        FileWriterDelegate::FLUSH_ON_COMPLETION);
+    return new FileWriterDelegate(scoped_ptr<storage::FileStreamWriter>(writer),
+                                  FileWriterDelegate::FLUSH_ON_COMPLETION);
   }
 
   FileWriterDelegate::DelegateWriteCallback GetWriteCallback(Result* result) {
@@ -147,7 +146,7 @@ class FileWriterDelegateTest : public PlatformTest {
   // This should be alive until the very end of this instance.
   base::MessageLoopForIO loop_;
 
-  scoped_refptr<fileapi::FileSystemContext> file_system_context_;
+  scoped_refptr<storage::FileSystemContext> file_system_context_;
 
   net::URLRequestContext empty_context_;
   scoped_ptr<FileWriterDelegate> file_writer_delegate_;
diff --git a/content/browser/fileapi/fileapi_message_filter.cc b/content/browser/fileapi/fileapi_message_filter.cc
index 2eb601a..09f81c3 100644
--- a/content/browser/fileapi/fileapi_message_filter.cc
+++ b/content/browser/fileapi/fileapi_message_filter.cc
@@ -40,12 +40,12 @@
 #include "webkit/common/fileapi/file_system_types.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
-using fileapi::FileSystemFileUtil;
-using fileapi::FileSystemBackend;
-using fileapi::FileSystemOperation;
-using fileapi::FileSystemURL;
-using webkit_blob::BlobData;
-using webkit_blob::BlobStorageContext;
+using storage::FileSystemFileUtil;
+using storage::FileSystemBackend;
+using storage::FileSystemOperation;
+using storage::FileSystemURL;
+using storage::BlobData;
+using storage::BlobStorageContext;
 
 namespace content {
 
@@ -66,11 +66,11 @@ void RevokeFilePermission(int child_id, const base::FilePath& path) {
 FileAPIMessageFilter::FileAPIMessageFilter(
     int process_id,
     net::URLRequestContextGetter* request_context_getter,
-    fileapi::FileSystemContext* file_system_context,
+    storage::FileSystemContext* file_system_context,
     ChromeBlobStorageContext* blob_storage_context,
     StreamContext* stream_context)
-    : BrowserMessageFilter(
-          kFilteredMessageClasses, arraysize(kFilteredMessageClasses)),
+    : BrowserMessageFilter(kFilteredMessageClasses,
+                           arraysize(kFilteredMessageClasses)),
       process_id_(process_id),
       context_(file_system_context),
       security_policy_(ChildProcessSecurityPolicyImpl::GetInstance()),
@@ -87,11 +87,11 @@ FileAPIMessageFilter::FileAPIMessageFilter(
 FileAPIMessageFilter::FileAPIMessageFilter(
     int process_id,
     net::URLRequestContext* request_context,
-    fileapi::FileSystemContext* file_system_context,
+    storage::FileSystemContext* file_system_context,
     ChromeBlobStorageContext* blob_storage_context,
     StreamContext* stream_context)
-    : BrowserMessageFilter(
-          kFilteredMessageClasses, arraysize(kFilteredMessageClasses)),
+    : BrowserMessageFilter(kFilteredMessageClasses,
+                           arraysize(kFilteredMessageClasses)),
       process_id_(process_id),
       context_(file_system_context),
       security_policy_(ChildProcessSecurityPolicyImpl::GetInstance()),
@@ -203,15 +203,15 @@ void FileAPIMessageFilter::BadMessageReceived() {
 
 void FileAPIMessageFilter::OnOpenFileSystem(int request_id,
                                             const GURL& origin_url,
-                                            fileapi::FileSystemType type) {
+                                            storage::FileSystemType type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  if (type == fileapi::kFileSystemTypeTemporary) {
+  if (type == storage::kFileSystemTypeTemporary) {
     RecordAction(base::UserMetricsAction("OpenFileSystemTemporary"));
-  } else if (type == fileapi::kFileSystemTypePersistent) {
+  } else if (type == storage::kFileSystemTypePersistent) {
     RecordAction(base::UserMetricsAction("OpenFileSystemPersistent"));
   }
-  fileapi::OpenFileSystemMode mode =
-      fileapi::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT;
+  storage::OpenFileSystemMode mode =
+      storage::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT;
   context_->OpenFileSystem(origin_url, type, mode, base::Bind(
       &FileAPIMessageFilter::DidOpenFileSystem, this, request_id));
 }
@@ -233,10 +233,9 @@ void FileAPIMessageFilter::OnResolveURL(
       &FileAPIMessageFilter::DidResolveURL, this, request_id));
 }
 
-void FileAPIMessageFilter::OnDeleteFileSystem(
-    int request_id,
-    const GURL& origin_url,
-    fileapi::FileSystemType type) {
+void FileAPIMessageFilter::OnDeleteFileSystem(int request_id,
+                                              const GURL& origin_url,
+                                              storage::FileSystemType type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   context_->DeleteFileSystem(origin_url, type, base::Bind(
       &FileAPIMessageFilter::DidDeleteFileSystem, this, request_id));
@@ -260,8 +259,9 @@ void FileAPIMessageFilter::OnMove(
   }
 
   operations_[request_id] = operation_runner()->Move(
-      src_url, dest_url,
-      fileapi::FileSystemOperation::OPTION_NONE,
+      src_url,
+      dest_url,
+      storage::FileSystemOperation::OPTION_NONE,
       base::Bind(&FileAPIMessageFilter::DidFinish, this, request_id));
 }
 
@@ -282,9 +282,10 @@ void FileAPIMessageFilter::OnCopy(
   }
 
   operations_[request_id] = operation_runner()->Copy(
-      src_url, dest_url,
-      fileapi::FileSystemOperation::OPTION_NONE,
-      fileapi::FileSystemOperationRunner::CopyProgressCallback(),
+      src_url,
+      dest_url,
+      storage::FileSystemOperation::OPTION_NONE,
+      storage::FileSystemOperationRunner::CopyProgressCallback(),
       base::Bind(&FileAPIMessageFilter::DidFinish, this, request_id));
 }
 
@@ -406,7 +407,7 @@ void FileAPIMessageFilter::OnWrite(
     return;
   }
 
-  scoped_ptr<webkit_blob::BlobDataHandle> blob =
+  scoped_ptr<storage::BlobDataHandle> blob =
       blob_storage_context_->context()->GetBlobDataFromUUID(blob_uuid);
 
   operations_[request_id] = operation_runner()->Write(
@@ -726,7 +727,7 @@ void FileAPIMessageFilter::DidGetMetadataForStreaming(
 void FileAPIMessageFilter::DidReadDirectory(
     int request_id,
     base::File::Error result,
-    const std::vector<fileapi::DirectoryEntry>& entries,
+    const std::vector<storage::DirectoryEntry>& entries,
     bool has_more) {
   if (result == base::File::FILE_OK) {
     if (!entries.empty() || !has_more)
@@ -771,19 +772,21 @@ void FileAPIMessageFilter::DidOpenFileSystem(int request_id,
 void FileAPIMessageFilter::DidResolveURL(
     int request_id,
     base::File::Error result,
-    const fileapi::FileSystemInfo& info,
+    const storage::FileSystemInfo& info,
     const base::FilePath& file_path,
-    fileapi::FileSystemContext::ResolvedEntryType type) {
+    storage::FileSystemContext::ResolvedEntryType type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (result == base::File::FILE_OK &&
-      type == fileapi::FileSystemContext::RESOLVED_ENTRY_NOT_FOUND)
+      type == storage::FileSystemContext::RESOLVED_ENTRY_NOT_FOUND)
     result = base::File::FILE_ERROR_NOT_FOUND;
 
   if (result == base::File::FILE_OK) {
     DCHECK(info.root_url.is_valid());
     Send(new FileSystemMsg_DidResolveURL(
-        request_id, info, file_path,
-        type == fileapi::FileSystemContext::RESOLVED_ENTRY_DIRECTORY));
+        request_id,
+        info,
+        file_path,
+        type == storage::FileSystemContext::RESOLVED_ENTRY_DIRECTORY));
   } else {
     Send(new FileSystemMsg_DidFail(request_id, result));
   }
@@ -803,11 +806,11 @@ void FileAPIMessageFilter::DidDeleteFileSystem(
 
 void FileAPIMessageFilter::DidCreateSnapshot(
     int request_id,
-    const fileapi::FileSystemURL& url,
+    const storage::FileSystemURL& url,
     base::File::Error result,
     const base::File::Info& info,
     const base::FilePath& platform_path,
-    const scoped_refptr<webkit_blob::ShareableFileReference>& /* unused */) {
+    const scoped_refptr<storage::ShareableFileReference>& /* unused */) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   operations_.erase(request_id);
 
@@ -816,8 +819,8 @@ void FileAPIMessageFilter::DidCreateSnapshot(
     return;
   }
 
-  scoped_refptr<webkit_blob::ShareableFileReference> file_ref =
-      webkit_blob::ShareableFileReference::Get(platform_path);
+  scoped_refptr<storage::ShareableFileReference> file_ref =
+      storage::ShareableFileReference::Get(platform_path);
   if (!security_policy_->CanReadFile(process_id_, platform_path)) {
     // Give per-file read permission to the snapshot file if it hasn't it yet.
     // In order for the renderer to be able to read the file via File object,
@@ -831,9 +834,9 @@ void FileAPIMessageFilter::DidCreateSnapshot(
     // is dropped.
     if (!file_ref.get()) {
       // Create a reference for temporary permission handling.
-      file_ref = webkit_blob::ShareableFileReference::GetOrCreate(
+      file_ref = storage::ShareableFileReference::GetOrCreate(
           platform_path,
-          webkit_blob::ShareableFileReference::DONT_DELETE_ON_FINAL_RELEASE,
+          storage::ShareableFileReference::DONT_DELETE_ON_FINAL_RELEASE,
           context_->default_file_task_runner());
     }
     file_ref->AddFinalReleaseCallback(
@@ -851,7 +854,8 @@ void FileAPIMessageFilter::DidCreateSnapshot(
 }
 
 bool FileAPIMessageFilter::ValidateFileSystemURL(
-    int request_id, const fileapi::FileSystemURL& url) {
+    int request_id,
+    const storage::FileSystemURL& url) {
   if (!FileSystemURLIsValid(context_, url)) {
     Send(new FileSystemMsg_DidFail(request_id,
                                    base::File::FILE_ERROR_INVALID_URL));
@@ -861,7 +865,7 @@ bool FileAPIMessageFilter::ValidateFileSystemURL(
   // Deny access to files in PluginPrivate FileSystem from JavaScript.
   // TODO(nhiroki): Move this filter somewhere else since this is not for
   // validation.
-  if (url.type() == fileapi::kFileSystemTypePluginPrivate) {
+  if (url.type() == storage::kFileSystemTypePluginPrivate) {
     Send(new FileSystemMsg_DidFail(request_id,
                                    base::File::FILE_ERROR_SECURITY));
     return false;
diff --git a/content/browser/fileapi/fileapi_message_filter.h b/content/browser/fileapi/fileapi_message_filter.h
index 7a98b1483..ca4165d 100644
--- a/content/browser/fileapi/fileapi_message_filter.h
+++ b/content/browser/fileapi/fileapi_message_filter.h
@@ -31,7 +31,7 @@ class FilePath;
 class Time;
 }
 
-namespace fileapi {
+namespace storage {
 class FileSystemURL;
 class FileSystemOperationRunner;
 struct DirectoryEntry;
@@ -47,7 +47,7 @@ namespace content {
 class BlobStorageHost;
 }
 
-namespace webkit_blob {
+namespace storage {
 class ShareableFileReference;
 }
 
@@ -60,19 +60,17 @@ class ChromeBlobStorageContext;
 class CONTENT_EXPORT FileAPIMessageFilter : public BrowserMessageFilter {
  public:
   // Used by the renderer process host on the UI thread.
-  FileAPIMessageFilter(
-      int process_id,
-      net::URLRequestContextGetter* request_context_getter,
-      fileapi::FileSystemContext* file_system_context,
-      ChromeBlobStorageContext* blob_storage_context,
-      StreamContext* stream_context);
+  FileAPIMessageFilter(int process_id,
+                       net::URLRequestContextGetter* request_context_getter,
+                       storage::FileSystemContext* file_system_context,
+                       ChromeBlobStorageContext* blob_storage_context,
+                       StreamContext* stream_context);
   // Used by the worker process host on the IO thread.
-  FileAPIMessageFilter(
-      int process_id,
-      net::URLRequestContext* request_context,
-      fileapi::FileSystemContext* file_system_context,
-      ChromeBlobStorageContext* blob_storage_context,
-      StreamContext* stream_context);
+  FileAPIMessageFilter(int process_id,
+                       net::URLRequestContext* request_context,
+                       storage::FileSystemContext* file_system_context,
+                       ChromeBlobStorageContext* blob_storage_context,
+                       StreamContext* stream_context);
 
   // BrowserMessageFilter implementation.
   virtual void OnChannelConnected(int32 peer_pid) OVERRIDE;
@@ -87,16 +85,16 @@ class CONTENT_EXPORT FileAPIMessageFilter : public BrowserMessageFilter {
   virtual void BadMessageReceived() OVERRIDE;
 
  private:
-  typedef fileapi::FileSystemOperationRunner::OperationID OperationID;
+  typedef storage::FileSystemOperationRunner::OperationID OperationID;
 
   void OnOpenFileSystem(int request_id,
                         const GURL& origin_url,
-                        fileapi::FileSystemType type);
+                        storage::FileSystemType type);
   void OnResolveURL(int request_id,
                     const GURL& filesystem_url);
   void OnDeleteFileSystem(int request_id,
                           const GURL& origin_url,
-                          fileapi::FileSystemType type);
+                          storage::FileSystemType type);
   void OnMove(int request_id,
               const GURL& src_path,
               const GURL& dest_path);
@@ -132,7 +130,7 @@ class CONTENT_EXPORT FileAPIMessageFilter : public BrowserMessageFilter {
 
   void OnStartBuildingBlob(const std::string& uuid);
   void OnAppendBlobDataItemToBlob(const std::string& uuid,
-                                  const webkit_blob::BlobData::Item& item);
+                                  const storage::BlobData::Item& item);
   void OnAppendSharedMemoryToBlob(const std::string& uuid,
                                   base::SharedMemoryHandle handle,
                                   size_t buffer_size);
@@ -152,8 +150,8 @@ class CONTENT_EXPORT FileAPIMessageFilter : public BrowserMessageFilter {
   //
   // TODO(tyoshino): Set |content_type| to the stream.
   void OnStartBuildingStream(const GURL& url, const std::string& content_type);
-  void OnAppendBlobDataItemToStream(
-      const GURL& url, const webkit_blob::BlobData::Item& item);
+  void OnAppendBlobDataItemToStream(const GURL& url,
+                                    const storage::BlobData::Item& item);
   void OnAppendSharedMemoryToStream(
       const GURL& url, base::SharedMemoryHandle handle, size_t buffer_size);
   void OnFinishBuildingStream(const GURL& url);
@@ -171,7 +169,7 @@ class CONTENT_EXPORT FileAPIMessageFilter : public BrowserMessageFilter {
                                   const base::File::Info& info);
   void DidReadDirectory(int request_id,
                         base::File::Error result,
-                        const std::vector<fileapi::DirectoryEntry>& entries,
+                        const std::vector<storage::DirectoryEntry>& entries,
                         bool has_more);
   void DidWrite(int request_id,
                 base::File::Error result,
@@ -183,34 +181,34 @@ class CONTENT_EXPORT FileAPIMessageFilter : public BrowserMessageFilter {
                          base::File::Error result);
   void DidResolveURL(int request_id,
                      base::File::Error result,
-                     const fileapi::FileSystemInfo& info,
+                     const storage::FileSystemInfo& info,
                      const base::FilePath& file_path,
-                     fileapi::FileSystemContext::ResolvedEntryType type);
+                     storage::FileSystemContext::ResolvedEntryType type);
   void DidDeleteFileSystem(int request_id,
                            base::File::Error result);
   void DidCreateSnapshot(
       int request_id,
-      const fileapi::FileSystemURL& url,
+      const storage::FileSystemURL& url,
       base::File::Error result,
       const base::File::Info& info,
       const base::FilePath& platform_path,
-      const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref);
+      const scoped_refptr<storage::ShareableFileReference>& file_ref);
 
   // Sends a FileSystemMsg_DidFail and returns false if |url| is invalid.
-  bool ValidateFileSystemURL(int request_id, const fileapi::FileSystemURL& url);
+  bool ValidateFileSystemURL(int request_id, const storage::FileSystemURL& url);
 
   // Retrieves the Stream object for |url| from |stream_context_|. Returns unset
   // scoped_refptr when there's no Stream instance for the given |url|
   // registered with stream_context_->registry().
   scoped_refptr<Stream> GetStreamForURL(const GURL& url);
 
-  fileapi::FileSystemOperationRunner* operation_runner() {
+  storage::FileSystemOperationRunner* operation_runner() {
     return operation_runner_.get();
   }
 
   int process_id_;
 
-  fileapi::FileSystemContext* context_;
+  storage::FileSystemContext* context_;
   ChildProcessSecurityPolicyImpl* security_policy_;
 
   // Keeps map from request_id to OperationID for ongoing operations.
@@ -226,7 +224,7 @@ class CONTENT_EXPORT FileAPIMessageFilter : public BrowserMessageFilter {
   scoped_refptr<ChromeBlobStorageContext> blob_storage_context_;
   scoped_refptr<StreamContext> stream_context_;
 
-  scoped_ptr<fileapi::FileSystemOperationRunner> operation_runner_;
+  scoped_ptr<storage::FileSystemOperationRunner> operation_runner_;
 
   // Keeps track of blobs used in this process and cleans up
   // when the renderer process dies.
@@ -238,7 +236,7 @@ class CONTENT_EXPORT FileAPIMessageFilter : public BrowserMessageFilter {
 
   // Used to keep snapshot files alive while a DidCreateSnapshot
   // is being sent to the renderer.
-  std::map<int, scoped_refptr<webkit_blob::ShareableFileReference> >
+  std::map<int, scoped_refptr<storage::ShareableFileReference> >
       in_transit_snapshot_files_;
 
   DISALLOW_COPY_AND_ASSIGN(FileAPIMessageFilter);
diff --git a/content/browser/fileapi/fileapi_message_filter_unittest.cc b/content/browser/fileapi/fileapi_message_filter_unittest.cc
index 3a4c47e9..ddd3028 100644
--- a/content/browser/fileapi/fileapi_message_filter_unittest.cc
+++ b/content/browser/fileapi/fileapi_message_filter_unittest.cc
@@ -52,13 +52,13 @@ class FileAPIMessageFilterTest : public testing::Test {
     file_system_context_ =
         CreateFileSystemContextForTesting(NULL, base::FilePath());
 
-    std::vector<fileapi::FileSystemType> types;
+    std::vector<storage::FileSystemType> types;
     file_system_context_->GetFileSystemTypes(&types);
     for (size_t i = 0; i < types.size(); ++i) {
-      ChildProcessSecurityPolicyImpl::GetInstance()->
-          RegisterFileSystemPermissionPolicy(
+      ChildProcessSecurityPolicyImpl::GetInstance()
+          ->RegisterFileSystemPermissionPolicy(
               types[i],
-              fileapi::FileSystemContext::GetPermissionPolicy(types[i]));
+              storage::FileSystemContext::GetPermissionPolicy(types[i]));
     }
 
     stream_context_ = StreamContext::GetFor(&browser_context_);
@@ -79,7 +79,7 @@ class FileAPIMessageFilterTest : public testing::Test {
   TestBrowserThread io_browser_thread_;
 
   TestBrowserContext browser_context_;
-  scoped_refptr<fileapi::FileSystemContext> file_system_context_;
+  scoped_refptr<storage::FileSystemContext> file_system_context_;
   StreamContext* stream_context_;
   ChromeBlobStorageContext* blob_storage_context_;
 
@@ -197,7 +197,7 @@ TEST_F(FileAPIMessageFilterTest, BuildNonEmptyStream) {
   StreamHostMsg_StartBuilding start_message(kUrl, kFakeContentType);
   EXPECT_TRUE(filter_->OnMessageReceived(start_message));
 
-  webkit_blob::BlobData::Item item;
+  storage::BlobData::Item item;
   const std::string kFakeData = "foobarbaz";
   item.SetToBytes(kFakeData.data(), kFakeData.size());
   StreamHostMsg_AppendBlobDataItem append_message(kUrl, item);
diff --git a/content/browser/fileapi/isolated_context_unittest.cc b/content/browser/fileapi/isolated_context_unittest.cc
index be5cc8e..bdfcba4 100644
--- a/content/browser/fileapi/isolated_context_unittest.cc
+++ b/content/browser/fileapi/isolated_context_unittest.cc
@@ -18,12 +18,12 @@
 #define DRIVE
 #endif
 
-using fileapi::FileSystemMountOption;
-using fileapi::FileSystemURL;
-using fileapi::IsolatedContext;
-using fileapi::kFileSystemTypeDragged;
-using fileapi::kFileSystemTypeIsolated;
-using fileapi::kFileSystemTypeNativeLocal;
+using storage::FileSystemMountOption;
+using storage::FileSystemURL;
+using storage::IsolatedContext;
+using storage::kFileSystemTypeDragged;
+using storage::kFileSystemTypeIsolated;
+using storage::kFileSystemTypeNativeLocal;
 
 namespace content {
 
@@ -103,7 +103,7 @@ TEST_F(IsolatedContextTest, RegisterAndRevokeTest) {
     std::string cracked_id;
     base::FilePath cracked_path;
     std::string cracked_inner_id;
-    fileapi::FileSystemType cracked_type;
+    storage::FileSystemType cracked_type;
     FileSystemMountOption cracked_option;
     ASSERT_TRUE(isolated_context()->CrackVirtualPath(
         virtual_path, &cracked_id, &cracked_type, &cracked_inner_id,
@@ -203,7 +203,7 @@ TEST_F(IsolatedContextTest, CrackWithRelativePaths) {
               names_[i]).Append(relatives[j].path);
       std::string cracked_id;
       base::FilePath cracked_path;
-      fileapi::FileSystemType cracked_type;
+      storage::FileSystemType cracked_type;
       std::string cracked_inner_id;
       FileSystemMountOption cracked_option;
       if (!relatives[j].valid) {
@@ -299,35 +299,36 @@ TEST_F(IsolatedContextTest, CanHandleURL) {
 
   // Should handle isolated file system.
   EXPECT_TRUE(isolated_context()->HandlesFileSystemMountType(
-      fileapi::kFileSystemTypeIsolated));
+      storage::kFileSystemTypeIsolated));
 
   // Shouldn't handle the rest.
   EXPECT_FALSE(isolated_context()->HandlesFileSystemMountType(
-      fileapi::kFileSystemTypeExternal));
+      storage::kFileSystemTypeExternal));
   EXPECT_FALSE(isolated_context()->HandlesFileSystemMountType(
-      fileapi::kFileSystemTypeTemporary));
+      storage::kFileSystemTypeTemporary));
   EXPECT_FALSE(isolated_context()->HandlesFileSystemMountType(
-      fileapi::kFileSystemTypePersistent));
+      storage::kFileSystemTypePersistent));
   EXPECT_FALSE(isolated_context()->HandlesFileSystemMountType(
-      fileapi::kFileSystemTypeTest));
+      storage::kFileSystemTypeTest));
   // Not even if it's isolated subtype.
   EXPECT_FALSE(isolated_context()->HandlesFileSystemMountType(
-      fileapi::kFileSystemTypeNativeLocal));
+      storage::kFileSystemTypeNativeLocal));
   EXPECT_FALSE(isolated_context()->HandlesFileSystemMountType(
-      fileapi::kFileSystemTypeDragged));
+      storage::kFileSystemTypeDragged));
   EXPECT_FALSE(isolated_context()->HandlesFileSystemMountType(
-      fileapi::kFileSystemTypeNativeMedia));
+      storage::kFileSystemTypeNativeMedia));
   EXPECT_FALSE(isolated_context()->HandlesFileSystemMountType(
-      fileapi::kFileSystemTypeDeviceMedia));
+      storage::kFileSystemTypeDeviceMedia));
 }
 
 TEST_F(IsolatedContextTest, VirtualFileSystemTests) {
   // Should be able to register empty and non-absolute paths
   std::string empty_fsid = isolated_context()->RegisterFileSystemForVirtualPath(
-      fileapi::kFileSystemTypeIsolated, "_", base::FilePath());
+      storage::kFileSystemTypeIsolated, "_", base::FilePath());
   std::string relative_fsid =
       isolated_context()->RegisterFileSystemForVirtualPath(
-          fileapi::kFileSystemTypeIsolated, "_",
+          storage::kFileSystemTypeIsolated,
+          "_",
           base::FilePath(FPL("relpath")));
   ASSERT_FALSE(empty_fsid.empty());
   ASSERT_FALSE(relative_fsid.empty());
@@ -336,7 +337,7 @@ TEST_F(IsolatedContextTest, VirtualFileSystemTests) {
   base::FilePath database_root = base::FilePath(DRIVE FPL("/database_path"));
   std::string database_fsid =
       isolated_context()->RegisterFileSystemForVirtualPath(
-          fileapi::kFileSystemTypeIsolated, "_", database_root);
+          storage::kFileSystemTypeIsolated, "_", database_root);
 
   base::FilePath test_virtual_path =
       base::FilePath().AppendASCII("virtualdir").AppendASCII("virtualfile.txt");
diff --git a/content/browser/fileapi/local_file_stream_reader_unittest.cc b/content/browser/fileapi/local_file_stream_reader_unittest.cc
index c9547ed..d062631 100644
--- a/content/browser/fileapi/local_file_stream_reader_unittest.cc
+++ b/content/browser/fileapi/local_file_stream_reader_unittest.cc
@@ -18,7 +18,7 @@
 #include "net/base/test_completion_callback.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using webkit_blob::LocalFileStreamReader;
+using storage::LocalFileStreamReader;
 
 namespace content {
 
diff --git a/content/browser/fileapi/local_file_stream_writer_unittest.cc b/content/browser/fileapi/local_file_stream_writer_unittest.cc
index 97e5e1e..b6e3f93 100644
--- a/content/browser/fileapi/local_file_stream_writer_unittest.cc
+++ b/content/browser/fileapi/local_file_stream_writer_unittest.cc
@@ -18,8 +18,8 @@
 #include "net/base/test_completion_callback.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using fileapi::FileStreamWriter;
-using fileapi::LocalFileStreamWriter;
+using storage::FileStreamWriter;
+using storage::LocalFileStreamWriter;
 
 namespace content {
 
diff --git a/content/browser/fileapi/local_file_util_unittest.cc b/content/browser/fileapi/local_file_util_unittest.cc
index a20b18d..83ec6df 100644
--- a/content/browser/fileapi/local_file_util_unittest.cc
+++ b/content/browser/fileapi/local_file_util_unittest.cc
@@ -24,18 +24,18 @@
 #include "webkit/common/fileapi/file_system_types.h"
 
 using content::AsyncFileTestHelper;
-using fileapi::AsyncFileUtilAdapter;
-using fileapi::FileSystemContext;
-using fileapi::FileSystemOperationContext;
-using fileapi::FileSystemURL;
-using fileapi::LocalFileUtil;
+using storage::AsyncFileUtilAdapter;
+using storage::FileSystemContext;
+using storage::FileSystemOperationContext;
+using storage::FileSystemURL;
+using storage::LocalFileUtil;
 
 namespace content {
 
 namespace {
 
 const GURL kOrigin("http://foo/");
-const fileapi::FileSystemType kFileSystemType = fileapi::kFileSystemTypeTest;
+const storage::FileSystemType kFileSystemType = storage::kFileSystemTypeTest;
 
 }  // namespace
 
diff --git a/content/browser/fileapi/mock_file_change_observer.cc b/content/browser/fileapi/mock_file_change_observer.cc
index c37f175..f6a86e9 100644
--- a/content/browser/fileapi/mock_file_change_observer.cc
+++ b/content/browser/fileapi/mock_file_change_observer.cc
@@ -4,7 +4,7 @@
 
 #include "content/browser/fileapi/mock_file_change_observer.h"
 
-namespace fileapi {
+namespace storage {
 
 MockFileChangeObserver::MockFileChangeObserver()
     : create_file_count_(0),
@@ -48,4 +48,4 @@ void MockFileChangeObserver::OnRemoveDirectory(const FileSystemURL& url) {
   remove_directory_count_++;
 }
 
-}  // namespace fileapi
+}  // namespace storage
diff --git a/content/browser/fileapi/mock_file_change_observer.h b/content/browser/fileapi/mock_file_change_observer.h
index 4c1bcb2..faa509a 100644
--- a/content/browser/fileapi/mock_file_change_observer.h
+++ b/content/browser/fileapi/mock_file_change_observer.h
@@ -11,7 +11,7 @@
 #include "webkit/browser/fileapi/file_system_url.h"
 #include "webkit/browser/fileapi/task_runner_bound_observer_list.h"
 
-namespace fileapi {
+namespace storage {
 
 // Mock file change observer.
 class MockFileChangeObserver : public FileChangeObserver {
@@ -98,6 +98,6 @@ class MockFileChangeObserver : public FileChangeObserver {
   DISALLOW_COPY_AND_ASSIGN(MockFileChangeObserver);
 };
 
-}  // namespace fileapi
+}  // namespace storage
 
 #endif  // WEBKIT_BROWSER_FILEAPI_MOCK_FILE_CHANGE_OBSERVER_H_
diff --git a/content/browser/fileapi/native_file_util_unittest.cc b/content/browser/fileapi/native_file_util_unittest.cc
index e20914d..1636f74 100644
--- a/content/browser/fileapi/native_file_util_unittest.cc
+++ b/content/browser/fileapi/native_file_util_unittest.cc
@@ -11,9 +11,9 @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/browser/fileapi/native_file_util.h"
 
-using fileapi::FileSystemFileUtil;
-using fileapi::FileSystemOperation;
-using fileapi::NativeFileUtil;
+using storage::FileSystemFileUtil;
+using storage::FileSystemOperation;
+using storage::NativeFileUtil;
 
 namespace content {
 
diff --git a/content/browser/fileapi/obfuscated_file_util_unittest.cc b/content/browser/fileapi/obfuscated_file_util_unittest.cc
index 089cef8..0c41e8a 100644
--- a/content/browser/fileapi/obfuscated_file_util_unittest.cc
+++ b/content/browser/fileapi/obfuscated_file_util_unittest.cc
@@ -35,15 +35,15 @@
 #include "webkit/common/quota/quota_types.h"
 
 using content::AsyncFileTestHelper;
-using fileapi::FileSystemContext;
-using fileapi::FileSystemOperation;
-using fileapi::FileSystemOperationContext;
-using fileapi::FileSystemURL;
-using fileapi::ObfuscatedFileUtil;
-using fileapi::SandboxDirectoryDatabase;
-using fileapi::SandboxIsolatedOriginDatabase;
-using fileapi::kFileSystemTypeTemporary;
-using fileapi::kFileSystemTypePersistent;
+using storage::FileSystemContext;
+using storage::FileSystemOperation;
+using storage::FileSystemOperationContext;
+using storage::FileSystemURL;
+using storage::ObfuscatedFileUtil;
+using storage::SandboxDirectoryDatabase;
+using storage::SandboxIsolatedOriginDatabase;
+using storage::kFileSystemTypeTemporary;
+using storage::kFileSystemTypePersistent;
 
 namespace content {
 
@@ -121,16 +121,17 @@ FileSystemURL FileSystemURLAppendUTF8(
 
 FileSystemURL FileSystemURLDirName(const FileSystemURL& url) {
   return FileSystemURL::CreateForTest(
-      url.origin(), url.mount_type(),
-      fileapi::VirtualPath::DirName(url.virtual_path()));
+      url.origin(),
+      url.mount_type(),
+      storage::VirtualPath::DirName(url.virtual_path()));
 }
 
-std::string GetTypeString(fileapi::FileSystemType type) {
-  return fileapi::SandboxFileSystemBackendDelegate::GetTypeString(type);
+std::string GetTypeString(storage::FileSystemType type) {
+  return storage::SandboxFileSystemBackendDelegate::GetTypeString(type);
 }
 
 bool HasFileSystemType(ObfuscatedFileUtil::AbstractOriginEnumerator* enumerator,
-                       fileapi::FileSystemType type) {
+                       storage::FileSystemType type) {
   return enumerator->HasTypeDirectory(GetTypeString(type));
 }
 
@@ -144,12 +145,11 @@ class ObfuscatedFileUtilTest : public testing::Test {
  public:
   ObfuscatedFileUtilTest()
       : origin_(GURL("http://www.example.com")),
-        type_(fileapi::kFileSystemTypeTemporary),
+        type_(storage::kFileSystemTypeTemporary),
         weak_factory_(this),
         sandbox_file_system_(origin_, type_),
-        quota_status_(quota::kQuotaStatusUnknown),
-        usage_(-1) {
-  }
+        quota_status_(storage::kQuotaStatusUnknown),
+        usage_(-1) {}
 
   virtual void SetUp() {
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
@@ -157,11 +157,11 @@ class ObfuscatedFileUtilTest : public testing::Test {
     storage_policy_ = new MockSpecialStoragePolicy();
 
     quota_manager_ =
-        new quota::QuotaManager(false /* is_incognito */,
-                                data_dir_.path(),
-                                base::MessageLoopProxy::current().get(),
-                                base::MessageLoopProxy::current().get(),
-                                storage_policy_.get());
+        new storage::QuotaManager(false /* is_incognito */,
+                                  data_dir_.path(),
+                                  base::MessageLoopProxy::current().get(),
+                                  base::MessageLoopProxy::current().get(),
+                                  storage_policy_.get());
 
     // Every time we create a new sandbox_file_system helper,
     // it creates another context, which creates another path manager,
@@ -173,8 +173,8 @@ class ObfuscatedFileUtilTest : public testing::Test {
 
     sandbox_file_system_.SetUp(file_system_context_.get());
 
-    change_observers_ = fileapi::MockFileChangeObserver::CreateList(
-        &change_observer_);
+    change_observers_ =
+        storage::MockFileChangeObserver::CreateList(&change_observer_);
   }
 
   virtual void TearDown() {
@@ -208,11 +208,11 @@ class ObfuscatedFileUtilTest : public testing::Test {
     return context;
   }
 
-  const fileapi::ChangeObserverList& change_observers() const {
+  const storage::ChangeObserverList& change_observers() const {
     return change_observers_;
   }
 
-  fileapi::MockFileChangeObserver* change_observer() {
+  storage::MockFileChangeObserver* change_observer() {
     return &change_observer_;
   }
 
@@ -220,8 +220,8 @@ class ObfuscatedFileUtilTest : public testing::Test {
   // and obfuscated_file_util_.
   // Use this for tests which need to run in multiple origins; we need a test
   // helper per origin.
-  SandboxFileSystemTestHelper* NewFileSystem(
-      const GURL& origin, fileapi::FileSystemType type) {
+  SandboxFileSystemTestHelper* NewFileSystem(const GURL& origin,
+                                             storage::FileSystemType type) {
     SandboxFileSystemTestHelper* file_system =
         new SandboxFileSystemTestHelper(origin, type);
 
@@ -230,7 +230,7 @@ class ObfuscatedFileUtilTest : public testing::Test {
   }
 
   scoped_ptr<ObfuscatedFileUtil> CreateObfuscatedFileUtil(
-      quota::SpecialStoragePolicy* storage_policy) {
+      storage::SpecialStoragePolicy* storage_policy) {
     return scoped_ptr<ObfuscatedFileUtil>(
       ObfuscatedFileUtil::CreateForTesting(
           storage_policy, data_dir_path(), NULL,
@@ -249,9 +249,7 @@ class ObfuscatedFileUtilTest : public testing::Test {
     return origin_;
   }
 
-  fileapi::FileSystemType type() const {
-    return type_;
-  }
+  storage::FileSystemType type() const { return type_; }
 
   std::string type_string() const {
     return GetTypeString(type_);
@@ -270,7 +268,7 @@ class ObfuscatedFileUtilTest : public testing::Test {
                                               sandbox_file_system_.type(),
                                               &usage_,
                                               &quota);
-    EXPECT_EQ(quota::kQuotaStatusOk, quota_status_);
+    EXPECT_EQ(storage::kQuotaStatusOk, quota_status_);
   }
 
   void RevokeUsageCache() {
@@ -303,7 +301,7 @@ class ObfuscatedFileUtilTest : public testing::Test {
   }
 
   int64 usage() const { return usage_; }
-  fileapi::FileSystemUsageCache* usage_cache() {
+  storage::FileSystemUsageCache* usage_cache() {
     return sandbox_file_system_.usage_cache();
   }
 
@@ -440,7 +438,7 @@ class ObfuscatedFileUtilTest : public testing::Test {
       std::set<base::FilePath::StringType>* files,
       std::set<base::FilePath::StringType>* directories) {
     scoped_ptr<FileSystemOperationContext> context;
-    std::vector<fileapi::DirectoryEntry> entries;
+    std::vector<storage::DirectoryEntry> entries;
     EXPECT_EQ(base::File::FILE_OK,
               AsyncFileTestHelper::ReadDirectory(file_system_context(),
                                                  root_url, &entries));
@@ -482,17 +480,17 @@ class ObfuscatedFileUtilTest : public testing::Test {
     FillTestDirectory(root_url, &files, &directories);
 
     scoped_ptr<FileSystemOperationContext> context;
-    std::vector<fileapi::DirectoryEntry> entries;
+    std::vector<storage::DirectoryEntry> entries;
     context.reset(NewContext(NULL));
     EXPECT_EQ(base::File::FILE_OK,
               AsyncFileTestHelper::ReadDirectory(
                   file_system_context(), root_url, &entries));
-    std::vector<fileapi::DirectoryEntry>::iterator entry_iter;
+    std::vector<storage::DirectoryEntry>::iterator entry_iter;
     EXPECT_EQ(files.size() + directories.size(), entries.size());
     EXPECT_TRUE(change_observer()->HasNoChange());
     for (entry_iter = entries.begin(); entry_iter != entries.end();
         ++entry_iter) {
-      const fileapi::DirectoryEntry& entry = *entry_iter;
+      const storage::DirectoryEntry& entry = *entry_iter;
       std::set<base::FilePath::StringType>::iterator iter =
           files.find(entry.name);
       if (iter != files.end()) {
@@ -745,8 +743,7 @@ class ObfuscatedFileUtilTest : public testing::Test {
     // Initialize the directory with one origin using
     // SandboxIsolatedOriginDatabase.
     {
-      std::string origin_string =
-          webkit_database::GetIdentifierFromOrigin(origin_);
+      std::string origin_string = storage::GetIdentifierFromOrigin(origin_);
       SandboxIsolatedOriginDatabase database_old(
           origin_string, data_dir_path(),
           base::FilePath(
@@ -801,16 +798,16 @@ class ObfuscatedFileUtilTest : public testing::Test {
   base::ScopedTempDir data_dir_;
   base::MessageLoop message_loop_;
   scoped_refptr<MockSpecialStoragePolicy> storage_policy_;
-  scoped_refptr<quota::QuotaManager> quota_manager_;
+  scoped_refptr<storage::QuotaManager> quota_manager_;
   scoped_refptr<FileSystemContext> file_system_context_;
   GURL origin_;
-  fileapi::FileSystemType type_;
+  storage::FileSystemType type_;
   base::WeakPtrFactory<ObfuscatedFileUtilTest> weak_factory_;
   SandboxFileSystemTestHelper sandbox_file_system_;
-  quota::QuotaStatusCode quota_status_;
+  storage::QuotaStatusCode quota_status_;
   int64 usage_;
-  fileapi::MockFileChangeObserver change_observer_;
-  fileapi::ChangeObserverList change_observers_;
+  storage::MockFileChangeObserver change_observer_;
+  storage::ChangeObserverList change_observers_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ObfuscatedFileUtilTest);
@@ -1217,7 +1214,7 @@ TEST_F(ObfuscatedFileUtilTest, TestReadDirectoryOnFile) {
             ofu()->EnsureFileExists(context.get(), url, &created));
   ASSERT_TRUE(created);
 
-  std::vector<fileapi::DirectoryEntry> entries;
+  std::vector<storage::DirectoryEntry> entries;
   EXPECT_EQ(base::File::FILE_ERROR_NOT_A_DIRECTORY,
             AsyncFileTestHelper::ReadDirectory(file_system_context(), url,
                                                &entries));
@@ -1795,7 +1792,7 @@ TEST_F(ObfuscatedFileUtilTest, TestIncompleteDirectoryReading) {
     EXPECT_TRUE(created);
   }
 
-  std::vector<fileapi::DirectoryEntry> entries;
+  std::vector<storage::DirectoryEntry> entries;
   EXPECT_EQ(base::File::FILE_OK,
             AsyncFileTestHelper::ReadDirectory(
                 file_system_context(), empty_path, &entries));
@@ -2040,7 +2037,7 @@ TEST_F(ObfuscatedFileUtilTest, TestFileEnumeratorTimestamp) {
                          base::Time()));
 
   context.reset(NewContext(NULL));
-  scoped_ptr<fileapi::FileSystemFileUtil::AbstractFileEnumerator> file_enum(
+  scoped_ptr<storage::FileSystemFileUtil::AbstractFileEnumerator> file_enum(
       ofu()->CreateFileEnumerator(context.get(), dir, false));
 
   int count = 0;
diff --git a/content/browser/fileapi/plugin_private_file_system_backend_unittest.cc b/content/browser/fileapi/plugin_private_file_system_backend_unittest.cc
index 08fb9e0..aac644d 100644
--- a/content/browser/fileapi/plugin_private_file_system_backend_unittest.cc
+++ b/content/browser/fileapi/plugin_private_file_system_backend_unittest.cc
@@ -20,9 +20,9 @@
 #include "webkit/common/fileapi/file_system_util.h"
 
 using content::AsyncFileTestHelper;
-using fileapi::FileSystemContext;
-using fileapi::FileSystemURL;
-using fileapi::IsolatedContext;
+using storage::FileSystemContext;
+using storage::FileSystemURL;
+using storage::IsolatedContext;
 
 namespace content {
 
@@ -31,7 +31,7 @@ namespace {
 const GURL kOrigin("http://www.example.com");
 const std::string kPlugin1("plugin1");
 const std::string kPlugin2("plugin2");
-const fileapi::FileSystemType kType = fileapi::kFileSystemTypePluginPrivate;
+const storage::FileSystemType kType = storage::kFileSystemTypePluginPrivate;
 const std::string kRootName = "pluginprivate";
 
 void DidOpenFileSystem(base::File::Error* error_out,
@@ -63,7 +63,7 @@ class PluginPrivateFileSystemBackendTest : public testing::Test {
         root.virtual_path().AppendASCII(relative));
   }
 
-  fileapi::PluginPrivateFileSystemBackend* backend() const {
+  storage::PluginPrivateFileSystemBackend* backend() const {
     return context_->plugin_private_backend();
   }
 
@@ -79,8 +79,11 @@ TEST_F(PluginPrivateFileSystemBackendTest, OpenFileSystemBasic) {
   const std::string filesystem_id1 = RegisterFileSystem();
   base::File::Error error = base::File::FILE_ERROR_FAILED;
   backend()->OpenPrivateFileSystem(
-      kOrigin, kType, filesystem_id1, kPlugin1,
-      fileapi::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
+      kOrigin,
+      kType,
+      filesystem_id1,
+      kPlugin1,
+      storage::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
       base::Bind(&DidOpenFileSystem, &error));
   base::RunLoop().RunUntilIdle();
   ASSERT_EQ(base::File::FILE_OK, error);
@@ -89,15 +92,17 @@ TEST_F(PluginPrivateFileSystemBackendTest, OpenFileSystemBasic) {
   const std::string filesystem_id2 = RegisterFileSystem();
   error = base::File::FILE_ERROR_FAILED;
   backend()->OpenPrivateFileSystem(
-      kOrigin, kType, filesystem_id2, kPlugin1,
-      fileapi::OPEN_FILE_SYSTEM_FAIL_IF_NONEXISTENT,
+      kOrigin,
+      kType,
+      filesystem_id2,
+      kPlugin1,
+      storage::OPEN_FILE_SYSTEM_FAIL_IF_NONEXISTENT,
       base::Bind(&DidOpenFileSystem, &error));
   base::RunLoop().RunUntilIdle();
   ASSERT_EQ(base::File::FILE_OK, error);
 
-  const GURL root_url(
-      fileapi::GetIsolatedFileSystemRootURIString(
-          kOrigin, filesystem_id1, kRootName));
+  const GURL root_url(storage::GetIsolatedFileSystemRootURIString(
+      kOrigin, filesystem_id1, kRootName));
   FileSystemURL file = CreateURL(root_url, "foo");
   base::FilePath platform_path;
   EXPECT_EQ(base::File::FILE_OK,
@@ -114,8 +119,11 @@ TEST_F(PluginPrivateFileSystemBackendTest, PluginIsolation) {
   const std::string filesystem_id1 = RegisterFileSystem();
   base::File::Error error = base::File::FILE_ERROR_FAILED;
   backend()->OpenPrivateFileSystem(
-      kOrigin, kType, filesystem_id1, kPlugin1,
-      fileapi::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
+      kOrigin,
+      kType,
+      filesystem_id1,
+      kPlugin1,
+      storage::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
       base::Bind(&DidOpenFileSystem, &error));
   base::RunLoop().RunUntilIdle();
   ASSERT_EQ(base::File::FILE_OK, error);
@@ -123,16 +131,18 @@ TEST_F(PluginPrivateFileSystemBackendTest, PluginIsolation) {
   const std::string filesystem_id2 = RegisterFileSystem();
   error = base::File::FILE_ERROR_FAILED;
   backend()->OpenPrivateFileSystem(
-      kOrigin, kType, filesystem_id2, kPlugin2,
-      fileapi::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
+      kOrigin,
+      kType,
+      filesystem_id2,
+      kPlugin2,
+      storage::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
       base::Bind(&DidOpenFileSystem, &error));
   base::RunLoop().RunUntilIdle();
   ASSERT_EQ(base::File::FILE_OK, error);
 
   // Create 'foo' in kPlugin1.
-  const GURL root_url1(
-      fileapi::GetIsolatedFileSystemRootURIString(
-          kOrigin, filesystem_id1, kRootName));
+  const GURL root_url1(storage::GetIsolatedFileSystemRootURIString(
+      kOrigin, filesystem_id1, kRootName));
   FileSystemURL file1 = CreateURL(root_url1, "foo");
   base::FilePath platform_path;
   EXPECT_EQ(base::File::FILE_OK,
@@ -141,9 +151,8 @@ TEST_F(PluginPrivateFileSystemBackendTest, PluginIsolation) {
       context_.get(), file1, AsyncFileTestHelper::kDontCheckSize));
 
   // See the same path is not available in kPlugin2.
-  const GURL root_url2(
-      fileapi::GetIsolatedFileSystemRootURIString(
-          kOrigin, filesystem_id2, kRootName));
+  const GURL root_url2(storage::GetIsolatedFileSystemRootURIString(
+      kOrigin, filesystem_id2, kRootName));
   FileSystemURL file2 = CreateURL(root_url2, "foo");
   EXPECT_FALSE(AsyncFileTestHelper::FileExists(
       context_.get(), file2, AsyncFileTestHelper::kDontCheckSize));
diff --git a/content/browser/fileapi/recursive_operation_delegate_unittest.cc b/content/browser/fileapi/recursive_operation_delegate_unittest.cc
index a96a212..8fe83df 100644
--- a/content/browser/fileapi/recursive_operation_delegate_unittest.cc
+++ b/content/browser/fileapi/recursive_operation_delegate_unittest.cc
@@ -19,14 +19,14 @@
 #include "webkit/browser/fileapi/file_system_operation.h"
 #include "webkit/browser/fileapi/file_system_operation_runner.h"
 
-using fileapi::FileSystemContext;
-using fileapi::FileSystemOperationContext;
-using fileapi::FileSystemURL;
+using storage::FileSystemContext;
+using storage::FileSystemOperationContext;
+using storage::FileSystemURL;
 
 namespace content {
 namespace {
 
-class LoggingRecursiveOperation : public fileapi::RecursiveOperationDelegate {
+class LoggingRecursiveOperation : public storage::RecursiveOperationDelegate {
  public:
   struct LogEntry {
     enum Type {
@@ -41,11 +41,10 @@ class LoggingRecursiveOperation : public fileapi::RecursiveOperationDelegate {
   LoggingRecursiveOperation(FileSystemContext* file_system_context,
                             const FileSystemURL& root,
                             const StatusCallback& callback)
-      : fileapi::RecursiveOperationDelegate(file_system_context),
+      : storage::RecursiveOperationDelegate(file_system_context),
         root_(root),
         callback_(callback),
-        weak_factory_(this) {
-  }
+        weak_factory_(this) {}
   virtual ~LoggingRecursiveOperation() {}
 
   const std::vector<LogEntry>& log_entries() const { return log_entries_; }
@@ -117,7 +116,7 @@ void ReportStatus(base::File::Error* out_error,
 
 // To test the Cancel() during operation, calls Cancel() of |operation|
 // after |counter| times message posting.
-void CallCancelLater(fileapi::RecursiveOperationDelegate* operation,
+void CallCancelLater(storage::RecursiveOperationDelegate* operation,
                      int counter) {
   if (counter > 0) {
     base::MessageLoopProxy::current()->PostTask(
@@ -150,7 +149,7 @@ class RecursiveOperationDelegateTest : public testing::Test {
     return make_scoped_ptr(context);
   }
 
-  fileapi::FileSystemFileUtil* file_util() {
+  storage::FileSystemFileUtil* file_util() {
     return sandbox_file_system_.file_util();
   }
 
diff --git a/content/browser/fileapi/sandbox_database_test_helper.cc b/content/browser/fileapi/sandbox_database_test_helper.cc
index 3e29567..ece5d40 100644
--- a/content/browser/fileapi/sandbox_database_test_helper.cc
+++ b/content/browser/fileapi/sandbox_database_test_helper.cc
@@ -15,7 +15,7 @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
-using fileapi::FilePathToString;
+using storage::FilePathToString;
 
 namespace content {
 
diff --git a/content/browser/fileapi/sandbox_directory_database_unittest.cc b/content/browser/fileapi/sandbox_directory_database_unittest.cc
index 6bc3c56..62b14e6 100644
--- a/content/browser/fileapi/sandbox_directory_database_unittest.cc
+++ b/content/browser/fileapi/sandbox_directory_database_unittest.cc
@@ -20,8 +20,8 @@
 
 #define FPL(x) FILE_PATH_LITERAL(x)
 
-using fileapi::FilePathToString;
-using fileapi::SandboxDirectoryDatabase;
+using storage::FilePathToString;
+using storage::SandboxDirectoryDatabase;
 
 namespace content {
 
diff --git a/content/browser/fileapi/sandbox_file_system_backend_delegate_unittest.cc b/content/browser/fileapi/sandbox_file_system_backend_delegate_unittest.cc
index 935f6ce..3858361 100644
--- a/content/browser/fileapi/sandbox_file_system_backend_delegate_unittest.cc
+++ b/content/browser/fileapi/sandbox_file_system_backend_delegate_unittest.cc
@@ -15,7 +15,7 @@
 #include "url/gurl.h"
 #include "webkit/browser/fileapi/file_system_url.h"
 
-using fileapi::FileSystemURL;
+using storage::FileSystemURL;
 
 namespace content {
 
@@ -23,8 +23,9 @@ namespace {
 
 FileSystemURL CreateFileSystemURL(const char* path) {
   const GURL kOrigin("http://foo/");
-  return fileapi::FileSystemURL::CreateForTest(
-      kOrigin, fileapi::kFileSystemTypeTemporary,
+  return storage::FileSystemURL::CreateForTest(
+      kOrigin,
+      storage::kFileSystemTypeTemporary,
       base::FilePath::FromUTF8Unsafe(path));
 }
 
@@ -34,7 +35,7 @@ class SandboxFileSystemBackendDelegateTest : public testing::Test {
  protected:
   virtual void SetUp() {
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
-    delegate_.reset(new fileapi::SandboxFileSystemBackendDelegate(
+    delegate_.reset(new storage::SandboxFileSystemBackendDelegate(
         NULL /* quota_manager_proxy */,
         base::MessageLoopProxy::current().get(),
         data_dir_.path(),
@@ -48,7 +49,7 @@ class SandboxFileSystemBackendDelegateTest : public testing::Test {
 
   base::ScopedTempDir data_dir_;
   base::MessageLoop message_loop_;
-  scoped_ptr<fileapi::SandboxFileSystemBackendDelegate> delegate_;
+  scoped_ptr<storage::SandboxFileSystemBackendDelegate> delegate_;
 };
 
 TEST_F(SandboxFileSystemBackendDelegateTest, IsAccessValid) {
@@ -60,9 +61,9 @@ TEST_F(SandboxFileSystemBackendDelegateTest, IsAccessValid) {
 
   // Access from non-allowed scheme should be disallowed.
   EXPECT_FALSE(IsAccessValid(
-      FileSystemURL::CreateForTest(
-          GURL("unknown://bar"), fileapi::kFileSystemTypeTemporary,
-          base::FilePath::FromUTF8Unsafe("foo"))));
+      FileSystemURL::CreateForTest(GURL("unknown://bar"),
+                                   storage::kFileSystemTypeTemporary,
+                                   base::FilePath::FromUTF8Unsafe("foo"))));
 
   // Access with restricted name should be disallowed.
   EXPECT_FALSE(IsAccessValid(CreateFileSystemURL(".")));
diff --git a/content/browser/fileapi/sandbox_file_system_backend_unittest.cc b/content/browser/fileapi/sandbox_file_system_backend_unittest.cc
index eda3461..9fda699 100644
--- a/content/browser/fileapi/sandbox_file_system_backend_unittest.cc
+++ b/content/browser/fileapi/sandbox_file_system_backend_unittest.cc
@@ -20,9 +20,9 @@
 #include "webkit/browser/fileapi/sandbox_file_system_backend_delegate.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
-using fileapi::FileSystemURL;
-using fileapi::SandboxFileSystemBackend;
-using fileapi::SandboxFileSystemBackendDelegate;
+using storage::FileSystemURL;
+using storage::SandboxFileSystemBackend;
+using storage::SandboxFileSystemBackendDelegate;
 
 // PS stands for path separator.
 #if defined(FILE_PATH_USES_WIN_SEPARATORS)
@@ -36,38 +36,28 @@ namespace content {
 namespace {
 
 const struct RootPathTest {
-  fileapi::FileSystemType type;
+  storage::FileSystemType type;
   const char* origin_url;
   const char* expected_path;
 } kRootPathTestCases[] = {
-  { fileapi::kFileSystemTypeTemporary, "http://foo:1/",
-    "000" PS "t" },
-  { fileapi::kFileSystemTypePersistent, "http://foo:1/",
-    "000" PS "p" },
-  { fileapi::kFileSystemTypeTemporary, "http://bar.com/",
-    "001" PS "t" },
-  { fileapi::kFileSystemTypePersistent, "http://bar.com/",
-    "001" PS "p" },
-  { fileapi::kFileSystemTypeTemporary, "https://foo:2/",
-    "002" PS "t" },
-  { fileapi::kFileSystemTypePersistent, "https://foo:2/",
-    "002" PS "p" },
-  { fileapi::kFileSystemTypeTemporary, "https://bar.com/",
-    "003" PS "t" },
-  { fileapi::kFileSystemTypePersistent, "https://bar.com/",
-    "003" PS "p" },
+      {storage::kFileSystemTypeTemporary, "http://foo:1/", "000" PS "t"},
+      {storage::kFileSystemTypePersistent, "http://foo:1/", "000" PS "p"},
+      {storage::kFileSystemTypeTemporary, "http://bar.com/", "001" PS "t"},
+      {storage::kFileSystemTypePersistent, "http://bar.com/", "001" PS "p"},
+      {storage::kFileSystemTypeTemporary, "https://foo:2/", "002" PS "t"},
+      {storage::kFileSystemTypePersistent, "https://foo:2/", "002" PS "p"},
+      {storage::kFileSystemTypeTemporary, "https://bar.com/", "003" PS "t"},
+      {storage::kFileSystemTypePersistent, "https://bar.com/", "003" PS "p"},
 };
 
 const struct RootPathFileURITest {
-  fileapi::FileSystemType type;
+  storage::FileSystemType type;
   const char* origin_url;
   const char* expected_path;
   const char* virtual_path;
 } kRootPathFileURITestCases[] = {
-  { fileapi::kFileSystemTypeTemporary, "file:///",
-    "000" PS "t", NULL },
-  { fileapi::kFileSystemTypePersistent, "file:///",
-    "000" PS "p", NULL },
+      {storage::kFileSystemTypeTemporary, "file:///", "000" PS "t", NULL},
+      {storage::kFileSystemTypePersistent, "file:///", "000" PS "p", NULL},
 };
 
 void DidOpenFileSystem(base::File::Error* error_out,
@@ -86,7 +76,7 @@ class SandboxFileSystemBackendTest : public testing::Test {
     SetUpNewDelegate(CreateAllowFileAccessOptions());
   }
 
-  void SetUpNewDelegate(const fileapi::FileSystemOptions& options) {
+  void SetUpNewDelegate(const storage::FileSystemOptions& options) {
     delegate_.reset(new SandboxFileSystemBackendDelegate(
         NULL /* quota_manager_proxy */,
         base::MessageLoopProxy::current().get(),
@@ -95,18 +85,18 @@ class SandboxFileSystemBackendTest : public testing::Test {
         options));
   }
 
-  void SetUpNewBackend(const fileapi::FileSystemOptions& options) {
+  void SetUpNewBackend(const storage::FileSystemOptions& options) {
     SetUpNewDelegate(options);
     backend_.reset(new SandboxFileSystemBackend(delegate_.get()));
   }
 
-  fileapi::SandboxFileSystemBackendDelegate::OriginEnumerator*
+  storage::SandboxFileSystemBackendDelegate::OriginEnumerator*
   CreateOriginEnumerator() const {
     return backend_->CreateOriginEnumerator();
   }
 
   void CreateOriginTypeDirectory(const GURL& origin,
-                                 fileapi::FileSystemType type) {
+                                 storage::FileSystemType type) {
     base::FilePath target = delegate_->
         GetBaseDirectoryForOriginAndType(origin, type, true);
     ASSERT_TRUE(!target.empty());
@@ -114,8 +104,8 @@ class SandboxFileSystemBackendTest : public testing::Test {
   }
 
   bool GetRootPath(const GURL& origin_url,
-                   fileapi::FileSystemType type,
-                   fileapi::OpenFileSystemMode mode,
+                   storage::FileSystemType type,
+                   storage::OpenFileSystemMode mode,
                    base::FilePath* root_path) {
     base::File::Error error = base::File::FILE_OK;
       backend_->ResolveURL(
@@ -140,8 +130,8 @@ class SandboxFileSystemBackendTest : public testing::Test {
 
   base::ScopedTempDir data_dir_;
   base::MessageLoop message_loop_;
-  scoped_ptr<fileapi::SandboxFileSystemBackendDelegate> delegate_;
-  scoped_ptr<fileapi::SandboxFileSystemBackend> backend_;
+  scoped_ptr<storage::SandboxFileSystemBackendDelegate> delegate_;
+  scoped_ptr<storage::SandboxFileSystemBackend> backend_;
 };
 
 TEST_F(SandboxFileSystemBackendTest, Empty) {
@@ -170,12 +160,12 @@ TEST_F(SandboxFileSystemBackendTest, EnumerateOrigins) {
   std::set<GURL> temporary_set, persistent_set;
   for (size_t i = 0; i < temporary_size; ++i) {
     CreateOriginTypeDirectory(GURL(temporary_origins[i]),
-        fileapi::kFileSystemTypeTemporary);
+                              storage::kFileSystemTypeTemporary);
     temporary_set.insert(GURL(temporary_origins[i]));
   }
   for (size_t i = 0; i < persistent_size; ++i) {
     CreateOriginTypeDirectory(GURL(persistent_origins[i]),
-        fileapi::kFileSystemTypePersistent);
+                              storage::kFileSystemTypePersistent);
     persistent_set.insert(GURL(persistent_origins[i]));
   }
 
@@ -186,11 +176,11 @@ TEST_F(SandboxFileSystemBackendTest, EnumerateOrigins) {
   GURL current;
   while (!(current = enumerator->Next()).is_empty()) {
     SCOPED_TRACE(testing::Message() << "EnumerateOrigin " << current.spec());
-    if (enumerator->HasFileSystemType(fileapi::kFileSystemTypeTemporary)) {
+    if (enumerator->HasFileSystemType(storage::kFileSystemTypeTemporary)) {
       ASSERT_TRUE(temporary_set.find(current) != temporary_set.end());
       ++temporary_actual_size;
     }
-    if (enumerator->HasFileSystemType(fileapi::kFileSystemTypePersistent)) {
+    if (enumerator->HasFileSystemType(storage::kFileSystemTypePersistent)) {
       ASSERT_TRUE(persistent_set.find(current) != persistent_set.end());
       ++persistent_actual_size;
     }
@@ -213,7 +203,7 @@ TEST_F(SandboxFileSystemBackendTest, GetRootPathCreateAndExamine) {
     base::FilePath root_path;
     EXPECT_TRUE(GetRootPath(GURL(kRootPathTestCases[i].origin_url),
                             kRootPathTestCases[i].type,
-                            fileapi::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
+                            storage::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
                             &root_path));
 
     base::FilePath expected = file_system_path().AppendASCII(
@@ -233,7 +223,7 @@ TEST_F(SandboxFileSystemBackendTest, GetRootPathCreateAndExamine) {
     base::FilePath root_path;
     EXPECT_TRUE(GetRootPath(GURL(kRootPathTestCases[i].origin_url),
                             kRootPathTestCases[i].type,
-                            fileapi::OPEN_FILE_SYSTEM_FAIL_IF_NONEXISTENT,
+                            storage::OPEN_FILE_SYSTEM_FAIL_IF_NONEXISTENT,
                             &root_path));
     ASSERT_TRUE(returned_root_path.size() > i);
     EXPECT_EQ(returned_root_path[i].value(), root_path.value());
@@ -249,14 +239,16 @@ TEST_F(SandboxFileSystemBackendTest,
   GURL origin_url("http://foo.com:1/");
 
   base::FilePath root_path1;
-  EXPECT_TRUE(GetRootPath(origin_url, fileapi::kFileSystemTypeTemporary,
-                          fileapi::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
+  EXPECT_TRUE(GetRootPath(origin_url,
+                          storage::kFileSystemTypeTemporary,
+                          storage::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
                           &root_path1));
 
   SetUpNewBackend(CreateDisallowFileAccessOptions());
   base::FilePath root_path2;
-  EXPECT_TRUE(GetRootPath(origin_url, fileapi::kFileSystemTypeTemporary,
-                          fileapi::OPEN_FILE_SYSTEM_FAIL_IF_NONEXISTENT,
+  EXPECT_TRUE(GetRootPath(origin_url,
+                          storage::kFileSystemTypeTemporary,
+                          storage::OPEN_FILE_SYSTEM_FAIL_IF_NONEXISTENT,
                           &root_path2));
 
   EXPECT_EQ(root_path1.value(), root_path2.value());
@@ -271,7 +263,7 @@ TEST_F(SandboxFileSystemBackendTest, GetRootPathGetWithoutCreate) {
                  << kRootPathTestCases[i].expected_path);
     EXPECT_FALSE(GetRootPath(GURL(kRootPathTestCases[i].origin_url),
                              kRootPathTestCases[i].type,
-                             fileapi::OPEN_FILE_SYSTEM_FAIL_IF_NONEXISTENT,
+                             storage::OPEN_FILE_SYSTEM_FAIL_IF_NONEXISTENT,
                              NULL));
   }
 }
@@ -283,11 +275,10 @@ TEST_F(SandboxFileSystemBackendTest, GetRootPathInIncognito) {
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kRootPathTestCases); ++i) {
     SCOPED_TRACE(testing::Message() << "RootPath (incognito) #" << i << " "
                  << kRootPathTestCases[i].expected_path);
-    EXPECT_FALSE(
-        GetRootPath(GURL(kRootPathTestCases[i].origin_url),
-                    kRootPathTestCases[i].type,
-                    fileapi::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
-                    NULL));
+    EXPECT_FALSE(GetRootPath(GURL(kRootPathTestCases[i].origin_url),
+                             kRootPathTestCases[i].type,
+                             storage::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
+                             NULL));
   }
 }
 
@@ -296,11 +287,10 @@ TEST_F(SandboxFileSystemBackendTest, GetRootPathFileURI) {
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kRootPathFileURITestCases); ++i) {
     SCOPED_TRACE(testing::Message() << "RootPathFileURI (disallow) #"
                  << i << " " << kRootPathFileURITestCases[i].expected_path);
-    EXPECT_FALSE(
-        GetRootPath(GURL(kRootPathFileURITestCases[i].origin_url),
-                    kRootPathFileURITestCases[i].type,
-                    fileapi::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
-                    NULL));
+    EXPECT_FALSE(GetRootPath(GURL(kRootPathFileURITestCases[i].origin_url),
+                             kRootPathFileURITestCases[i].type,
+                             storage::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
+                             NULL));
   }
 }
 
@@ -312,7 +302,7 @@ TEST_F(SandboxFileSystemBackendTest, GetRootPathFileURIWithAllowFlag) {
     base::FilePath root_path;
     EXPECT_TRUE(GetRootPath(GURL(kRootPathFileURITestCases[i].origin_url),
                             kRootPathFileURITestCases[i].type,
-                            fileapi::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
+                            storage::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
                             &root_path));
     base::FilePath expected = file_system_path().AppendASCII(
         kRootPathFileURITestCases[i].expected_path);
diff --git a/content/browser/fileapi/sandbox_isolated_origin_database_unittest.cc b/content/browser/fileapi/sandbox_isolated_origin_database_unittest.cc
index fbf6a5e..f89db1d 100644
--- a/content/browser/fileapi/sandbox_isolated_origin_database_unittest.cc
+++ b/content/browser/fileapi/sandbox_isolated_origin_database_unittest.cc
@@ -9,7 +9,7 @@
 #include "webkit/browser/fileapi/sandbox_isolated_origin_database.h"
 #include "webkit/browser/fileapi/sandbox_origin_database.h"
 
-using fileapi::SandboxIsolatedOriginDatabase;
+using storage::SandboxIsolatedOriginDatabase;
 
 namespace content {
 
diff --git a/content/browser/fileapi/sandbox_origin_database_unittest.cc b/content/browser/fileapi/sandbox_origin_database_unittest.cc
index cda5b77..fc5ea3d 100644
--- a/content/browser/fileapi/sandbox_origin_database_unittest.cc
+++ b/content/browser/fileapi/sandbox_origin_database_unittest.cc
@@ -20,7 +20,7 @@
 #include "webkit/browser/fileapi/sandbox_origin_database.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
-using fileapi::SandboxOriginDatabase;
+using storage::SandboxOriginDatabase;
 
 namespace content {
 
diff --git a/content/browser/fileapi/sandbox_prioritized_origin_database_unittest.cc b/content/browser/fileapi/sandbox_prioritized_origin_database_unittest.cc
index e81dc7d..6f5eba2 100644
--- a/content/browser/fileapi/sandbox_prioritized_origin_database_unittest.cc
+++ b/content/browser/fileapi/sandbox_prioritized_origin_database_unittest.cc
@@ -9,9 +9,9 @@
 #include "webkit/browser/fileapi/sandbox_origin_database.h"
 #include "webkit/browser/fileapi/sandbox_prioritized_origin_database.h"
 
-using fileapi::SandboxOriginDatabase;
-using fileapi::SandboxOriginDatabaseInterface;
-using fileapi::SandboxPrioritizedOriginDatabase;
+using storage::SandboxOriginDatabase;
+using storage::SandboxOriginDatabaseInterface;
+using storage::SandboxPrioritizedOriginDatabase;
 
 namespace content {
 
diff --git a/content/browser/fileapi/timed_task_helper_unittest.cc b/content/browser/fileapi/timed_task_helper_unittest.cc
index 59e465c..5fcc6eb 100644
--- a/content/browser/fileapi/timed_task_helper_unittest.cc
+++ b/content/browser/fileapi/timed_task_helper_unittest.cc
@@ -12,7 +12,7 @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/browser/fileapi/timed_task_helper.h"
 
-using fileapi::TimedTaskHelper;
+using storage::TimedTaskHelper;
 
 namespace content {
 
diff --git a/content/browser/fileapi/transient_file_util_unittest.cc b/content/browser/fileapi/transient_file_util_unittest.cc
index 96df84f..9b87172 100644
--- a/content/browser/fileapi/transient_file_util_unittest.cc
+++ b/content/browser/fileapi/transient_file_util_unittest.cc
@@ -16,7 +16,7 @@
 #include "webkit/browser/fileapi/transient_file_util.h"
 #include "webkit/common/blob/scoped_file.h"
 
-using fileapi::FileSystemURL;
+using storage::FileSystemURL;
 
 namespace content {
 
@@ -28,7 +28,7 @@ class TransientFileUtilTest : public testing::Test {
   virtual void SetUp() OVERRIDE {
     file_system_context_ = CreateFileSystemContextForTesting(
         NULL, base::FilePath(FILE_PATH_LITERAL("dummy")));
-    transient_file_util_.reset(new fileapi::TransientFileUtil);
+    transient_file_util_.reset(new storage::TransientFileUtil);
 
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
   }
@@ -42,11 +42,11 @@ class TransientFileUtilTest : public testing::Test {
       FileSystemURL* file_url,
       base::FilePath* file_path) {
     EXPECT_TRUE(base::CreateTemporaryFileInDir(data_dir_.path(), file_path));
-    fileapi::IsolatedContext* isolated_context =
-        fileapi::IsolatedContext::GetInstance();
+    storage::IsolatedContext* isolated_context =
+        storage::IsolatedContext::GetInstance();
     std::string name = "tmp";
     std::string fsid = isolated_context->RegisterFileSystemForPath(
-        fileapi::kFileSystemTypeForTransientFile,
+        storage::kFileSystemTypeForTransientFile,
         std::string(),
         *file_path,
         &name);
@@ -54,25 +54,23 @@ class TransientFileUtilTest : public testing::Test {
     base::FilePath virtual_path = isolated_context->CreateVirtualRootPath(
         fsid).AppendASCII(name);
     *file_url = file_system_context_->CreateCrackedFileSystemURL(
-        GURL("http://foo"),
-        fileapi::kFileSystemTypeIsolated,
-        virtual_path);
+        GURL("http://foo"), storage::kFileSystemTypeIsolated, virtual_path);
   }
 
-  scoped_ptr<fileapi::FileSystemOperationContext> NewOperationContext() {
+  scoped_ptr<storage::FileSystemOperationContext> NewOperationContext() {
     return make_scoped_ptr(
-        new fileapi::FileSystemOperationContext(file_system_context_.get()));
+        new storage::FileSystemOperationContext(file_system_context_.get()));
   }
 
-  fileapi::FileSystemFileUtil* file_util() {
+  storage::FileSystemFileUtil* file_util() {
     return transient_file_util_.get();
   }
 
  private:
   base::MessageLoop message_loop_;
   base::ScopedTempDir data_dir_;
-  scoped_refptr<fileapi::FileSystemContext> file_system_context_;
-  scoped_ptr<fileapi::TransientFileUtil> transient_file_util_;
+  scoped_refptr<storage::FileSystemContext> file_system_context_;
+  scoped_ptr<storage::TransientFileUtil> transient_file_util_;
 
   DISALLOW_COPY_AND_ASSIGN(TransientFileUtilTest);
 };
@@ -94,12 +92,8 @@ TEST_F(TransientFileUtilTest, TransientFile) {
 
   // Create a snapshot file.
   {
-    webkit_blob::ScopedFile scoped_file =
-        file_util()->CreateSnapshotFile(NewOperationContext().get(),
-                                        temp_url,
-                                        &error,
-                                        &file_info,
-                                        &path);
+    storage::ScopedFile scoped_file = file_util()->CreateSnapshotFile(
+        NewOperationContext().get(), temp_url, &error, &file_info, &path);
     ASSERT_EQ(base::File::FILE_OK, error);
     ASSERT_EQ(temp_path, path);
     ASSERT_FALSE(file_info.is_directory);
diff --git a/content/browser/fileapi/upload_file_system_file_element_reader.cc b/content/browser/fileapi/upload_file_system_file_element_reader.cc
index 9e6a288..0cbc668f 100644
--- a/content/browser/fileapi/upload_file_system_file_element_reader.cc
+++ b/content/browser/fileapi/upload_file_system_file_element_reader.cc
@@ -15,7 +15,7 @@
 namespace content {
 
 UploadFileSystemFileElementReader::UploadFileSystemFileElementReader(
-    fileapi::FileSystemContext* file_system_context,
+    storage::FileSystemContext* file_system_context,
     const GURL& url,
     uint64 range_offset,
     uint64 range_length,
diff --git a/content/browser/fileapi/upload_file_system_file_element_reader.h b/content/browser/fileapi/upload_file_system_file_element_reader.h
index 1b33489..8c0becd 100644
--- a/content/browser/fileapi/upload_file_system_file_element_reader.h
+++ b/content/browser/fileapi/upload_file_system_file_element_reader.h
@@ -11,11 +11,11 @@
 #include "net/base/upload_element_reader.h"
 #include "url/gurl.h"
 
-namespace webkit_blob {
+namespace storage {
 class FileStreamReader;
 }
 
-namespace fileapi {
+namespace storage {
 class FileSystemContext;
 }
 
@@ -26,7 +26,7 @@ class CONTENT_EXPORT UploadFileSystemFileElementReader :
     NON_EXPORTED_BASE(public net::UploadElementReader) {
  public:
   UploadFileSystemFileElementReader(
-      fileapi::FileSystemContext* file_system_context,
+      storage::FileSystemContext* file_system_context,
       const GURL& url,
       uint64 range_offset,
       uint64 range_length,
@@ -45,13 +45,13 @@ class CONTENT_EXPORT UploadFileSystemFileElementReader :
   void OnGetLength(const net::CompletionCallback& callback, int64 result);
   void OnRead(const net::CompletionCallback& callback, int result);
 
-  scoped_refptr<fileapi::FileSystemContext> file_system_context_;
+  scoped_refptr<storage::FileSystemContext> file_system_context_;
   const GURL url_;
   const uint64 range_offset_;
   const uint64 range_length_;
   const base::Time expected_modification_time_;
 
-  scoped_ptr<webkit_blob::FileStreamReader> stream_reader_;
+  scoped_ptr<storage::FileStreamReader> stream_reader_;
 
   uint64 stream_length_;
   uint64 position_;
diff --git a/content/browser/fileapi/upload_file_system_file_element_reader_unittest.cc b/content/browser/fileapi/upload_file_system_file_element_reader_unittest.cc
index 641b968..18b65be 100644
--- a/content/browser/fileapi/upload_file_system_file_element_reader_unittest.cc
+++ b/content/browser/fileapi/upload_file_system_file_element_reader_unittest.cc
@@ -18,17 +18,17 @@
 #include "webkit/browser/fileapi/file_system_url.h"
 
 using content::AsyncFileTestHelper;
-using fileapi::FileSystemContext;
-using fileapi::FileSystemType;
-using fileapi::FileSystemURL;
+using storage::FileSystemContext;
+using storage::FileSystemType;
+using storage::FileSystemURL;
 
 namespace content {
 
 namespace {
 
 const char kFileSystemURLOrigin[] = "http://remote";
-const fileapi::FileSystemType kFileSystemType =
-    fileapi::kFileSystemTypeTemporary;
+const storage::FileSystemType kFileSystemType =
+    storage::kFileSystemTypeTemporary;
 
 }  // namespace
 
@@ -45,7 +45,7 @@ class UploadFileSystemFileElementReaderTest : public testing::Test {
     file_system_context_->OpenFileSystem(
         GURL(kFileSystemURLOrigin),
         kFileSystemType,
-        fileapi::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
+        storage::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
         base::Bind(&UploadFileSystemFileElementReaderTest::OnOpenFileSystem,
                    base::Unretained(this)));
     base::RunLoop().RunUntilIdle();
@@ -88,7 +88,7 @@ class UploadFileSystemFileElementReaderTest : public testing::Test {
                            const char* buf,
                            int buf_size,
                            base::Time* modification_time) {
-    fileapi::FileSystemURL url =
+    storage::FileSystemURL url =
         file_system_context_->CreateCrackedFileSystemURL(
             GURL(kFileSystemURLOrigin),
             kFileSystemType,