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

chrome/browser/browsing_data/browsing_data_file_system_helper_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/browsing_data/browsing_data_file_system_helper.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/test/test_browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_url.h"
 #include "webkit/common/fileapi/file_system_types.h"
 
 using content::BrowserContext;
 using content::BrowserThread;
 
 namespace {
 
-// Shorter names for fileapi::* constants.
-const fileapi::FileSystemType kTemporary = fileapi::kFileSystemTypeTemporary;
-const fileapi::FileSystemType kPersistent = fileapi::kFileSystemTypePersistent;
+// Shorter names for storage::* constants.
+const storage::FileSystemType kTemporary = storage::kFileSystemTypeTemporary;
+const storage::FileSystemType kPersistent = storage::kFileSystemTypePersistent;
 
 // We'll use these three distinct origins for testing, both as strings and as
 // GURLs in appropriate contexts.
 const char kTestOrigin1[] = "http://host1:1/";
 const char kTestOrigin2[] = "http://host2:2/";
 const char kTestOrigin3[] = "http://host3:3/";
 
 // Extensions and Devtools should be ignored.
 const char kTestOriginExt[] = "chrome-extension://abcdefghijklmnopqrstuvwxyz/";
 const char kTestOriginDevTools[] = "chrome-devtools://abcdefghijklmnopqrstuvw/";
@@ skipping 45 matching lines @@
     base::MessageLoop::current()->Run();
   }
 
   // Unblocks the current MessageLoop. Should be called in response to some sort
   // of async activity in a callback method.
   void Notify() {
     base::MessageLoop::current()->Quit();
   }
 
   // Callback that should be executed in response to
-  // fileapi::FileSystemContext::OpenFileSystem.
+  // storage::FileSystemContext::OpenFileSystem.
   void OpenFileSystemCallback(const GURL& root,
                               const std::string& name,
                               base::File::Error error) {
     open_file_system_result_ = error;
     Notify();
   }
 
   bool OpenFileSystem(const GURL& origin,
-                      fileapi::FileSystemType type,
-                      fileapi::OpenFileSystemMode open_mode) {
+                      storage::FileSystemType type,
+                      storage::OpenFileSystemMode open_mode) {
     BrowserContext::GetDefaultStoragePartition(profile_.get())->
         GetFileSystemContext()->OpenFileSystem(
             origin, type, open_mode,
             base::Bind(
                 &BrowsingDataFileSystemHelperTest::OpenFileSystemCallback,
                 base::Unretained(this)));
     BlockUntilNotified();
     return open_file_system_result_ == base::File::FILE_OK;
   }
 
-  // Calls fileapi::FileSystemContext::OpenFileSystem with
+  // Calls storage::FileSystemContext::OpenFileSystem with
   // OPEN_FILE_SYSTEM_FAIL_IF_NONEXISTENT flag
   // to verify the existence of a file system for a specified type and origin,
   // blocks until a response is available, then returns the result
   // synchronously to it's caller.
   bool FileSystemContainsOriginAndType(const GURL& origin,
-                                       fileapi::FileSystemType type) {
-    return OpenFileSystem(origin, type,
-                          fileapi::OPEN_FILE_SYSTEM_FAIL_IF_NONEXISTENT);
+                                       storage::FileSystemType type) {
+    return OpenFileSystem(
+        origin, type, storage::OPEN_FILE_SYSTEM_FAIL_IF_NONEXISTENT);
   }
 
   // Callback that should be executed in response to StartFetching(), and stores
   // found file systems locally so that they are available via GetFileSystems().
   void CallbackStartFetching(
       const std::list<BrowsingDataFileSystemHelper::FileSystemInfo>&
           file_system_info_list) {
     file_system_info_list_.reset(
         new std::list<BrowsingDataFileSystemHelper::FileSystemInfo>(
             file_system_info_list));
@@ skipping 30 matching lines @@
     EXPECT_TRUE(FileSystemContainsOriginAndType(kOrigin1, kTemporary));
     EXPECT_TRUE(FileSystemContainsOriginAndType(kOrigin2, kPersistent));
     EXPECT_FALSE(FileSystemContainsOriginAndType(kOrigin2, kTemporary));
     EXPECT_TRUE(FileSystemContainsOriginAndType(kOrigin3, kPersistent));
     EXPECT_TRUE(FileSystemContainsOriginAndType(kOrigin3, kTemporary));
   }
 
   // Calls OpenFileSystem with OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT
   // to create a filesystem of a given type for a specified origin.
   void CreateDirectoryForOriginAndType(const GURL& origin,
-                                       fileapi::FileSystemType type) {
-    OpenFileSystem(origin, type,
-                   fileapi::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT);
+                                       storage::FileSystemType type) {
+    OpenFileSystem(
+        origin, type, storage::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT);
     EXPECT_EQ(base::File::FILE_OK, open_file_system_result_);
   }
 
   // Returns a list of the FileSystemInfo objects gathered in the most recent
   // call to StartFetching().
   FileSystemInfoList* GetFileSystems() {
     return file_system_info_list_.get();
   }
 
  protected:
@@ skipping 24 matching lines @@
   bool test_hosts_found[3] = {false, false, false};
   for (std::list<BrowsingDataFileSystemHelper::FileSystemInfo>::iterator info =
        file_system_info_list_->begin(); info != file_system_info_list_->end();
        ++info) {
     if (info->origin == kOrigin1) {
       EXPECT_FALSE(test_hosts_found[0]);
       test_hosts_found[0] = true;
       EXPECT_FALSE(ContainsKey(info->usage_map, kPersistent));
       EXPECT_TRUE(ContainsKey(info->usage_map, kTemporary));
       EXPECT_EQ(kEmptyFileSystemSize,
-                info->usage_map[fileapi::kFileSystemTypeTemporary]);
+                info->usage_map[storage::kFileSystemTypeTemporary]);
     } else if (info->origin == kOrigin2) {
       EXPECT_FALSE(test_hosts_found[1]);
       test_hosts_found[1] = true;
       EXPECT_TRUE(ContainsKey(info->usage_map, kPersistent));
       EXPECT_FALSE(ContainsKey(info->usage_map, kTemporary));
       EXPECT_EQ(kEmptyFileSystemSize, info->usage_map[kPersistent]);
     } else if (info->origin == kOrigin3) {
       EXPECT_FALSE(test_hosts_found[2]);
       test_hosts_found[2] = true;
       EXPECT_TRUE(ContainsKey(info->usage_map, kPersistent));
@@ skipping 66 matching lines @@
 // extension and devtools schemes.
 TEST_F(BrowsingDataFileSystemHelperTest, IgnoreExtensionsAndDevTools) {
   ASSERT_TRUE(canned_helper_->empty());
   canned_helper_->AddFileSystem(kOriginExt, kTemporary, 0);
   ASSERT_TRUE(canned_helper_->empty());
   canned_helper_->AddFileSystem(kOriginDevTools, kTemporary, 0);
   ASSERT_TRUE(canned_helper_->empty());
 }
 
 }  // namespace