Change fileapi namespace to content for files that are moved under content/

content/browser/fileapi/file_system_quota_client_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/platform_file.h"
 #include "base/run_loop.h"
 #include "content/public/test/test_file_system_context.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 #include "webkit/browser/fileapi/async_file_test_helper.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_quota_client.h"
 #include "webkit/browser/fileapi/file_system_usage_cache.h"
 #include "webkit/browser/fileapi/obfuscated_file_util.h"
 #include "webkit/common/fileapi/file_system_types.h"
 #include "webkit/common/fileapi/file_system_util.h"
 #include "webkit/common/quota/quota_types.h"
 
-namespace fileapi {
+using fileapi::AsyncFileTestHelper;
+using fileapi::FileSystemQuotaClient;
+using fileapi::FileSystemType;
+using fileapi::FileSystemURL;
+
+namespace content {
 namespace {
 
 const char kDummyURL1[] = "http://www.dummy.org";
 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;
 
@@ skipping 36 matching lines @@
   }
 
   int64 GetOriginUsage(FileSystemQuotaClient* quota_client,
                        const std::string& origin_url,
                        quota::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,
+      quota::StorageType type) {
     origins_.clear();
     quota_client->GetOriginsForType(
         type,
         base::Bind(&FileSystemQuotaClientTest::OnGetOrigins,
                    weak_factory_.GetWeakPtr()));
     base::RunLoop().RunUntilIdle();
     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,
+      quota::StorageType type,
+      const std::string& host) {
     origins_.clear();
     quota_client->GetOriginsForHost(
         type, host,
         base::Bind(&FileSystemQuotaClientTest::OnGetOrigins,
                    weak_factory_.GetWeakPtr()));
     base::RunLoop().RunUntilIdle();
     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,
+      quota::StorageType type) {
     quota_client->GetOriginUsage(
         GURL(origin_url), type,
         base::Bind(&FileSystemQuotaClientTest::OnGetAdditionalUsage,
                    weak_factory_.GetWeakPtr()));
   }
 
   bool CreateFileSystemDirectory(const base::FilePath& file_path,
                                  const std::string& origin_url,
                                  quota::StorageType storage_type) {
-    FileSystemType type = QuotaStorageTypeToFileSystemType(storage_type);
+    FileSystemType type = fileapi::QuotaStorageTypeToFileSystemType(
+        storage_type);
     FileSystemURL url = file_system_context_->CreateCrackedFileSystemURL(
         GURL(origin_url), type, file_path);
 
     base::PlatformFileError result =
         AsyncFileTestHelper::CreateDirectory(file_system_context_, url);
     return result == base::PLATFORM_FILE_OK;
   }
 
   bool CreateFileSystemFile(const base::FilePath& file_path,
                             int64 file_size,
                             const std::string& origin_url,
                             quota::StorageType storage_type) {
     if (file_path.empty())
       return false;
 
-    FileSystemType type = QuotaStorageTypeToFileSystemType(storage_type);
+    FileSystemType type = fileapi::QuotaStorageTypeToFileSystemType(
+        storage_type);
     FileSystemURL url = file_system_context_->CreateCrackedFileSystemURL(
         GURL(origin_url), type, file_path);
 
     base::PlatformFileError result =
         AsyncFileTestHelper::CreateFile(file_system_context_, url);
     if (result != base::PLATFORM_FILE_OK)
       return false;
 
     result = AsyncFileTestHelper::TruncateFile(
         file_system_context_, url, file_size);
@@ skipping 31 matching lines @@
   int64 ComputeFilePathsCostForOriginAndType(const TestFile* files,
                                              int num_files,
                                              const std::string& origin_url,
                                              quota::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 += ObfuscatedFileUtil::ComputeFilePathCost(path);
+          file_paths_cost += fileapi::ObfuscatedFileUtil::ComputeFilePathCost(
+              path);
         }
       }
     }
     return file_paths_cost;
   }
 
   void DeleteOriginData(FileSystemQuotaClient* quota_client,
                         const std::string& origin,
                         quota::StorageType type) {
     deletion_status_ = quota::kQuotaStatusUnknown;
@@ skipping 22 matching lines @@
   void OnGetAdditionalUsage(int64 usage_unused) {
     ++additional_callback_count_;
   }
 
   void OnDeleteOrigin(quota::QuotaStatusCode status) {
     deletion_status_ = status;
   }
 
   base::ScopedTempDir data_dir_;
   base::MessageLoop message_loop_;
-  scoped_refptr<FileSystemContext> file_system_context_;
+  scoped_refptr<fileapi::FileSystemContext> file_system_context_;
   base::WeakPtrFactory<FileSystemQuotaClientTest> weak_factory_;
   int64 usage_;
   int additional_callback_count_;
   std::set<GURL> origins_;
   quota::QuotaStatusCode deletion_status_;
 
   DISALLOW_COPY_AND_ASSIGN(FileSystemQuotaClientTest);
 };
 
 TEST_F(FileSystemQuotaClientTest, NoFileSystemTest) {
@@ skipping 313 matching lines @@
   EXPECT_EQ(32 + file_paths_cost_persistent_bar_https,
             GetOriginUsage(quota_client.get(),
                            "https://bar.com/",
                            kPersistent));
   EXPECT_EQ(64 + file_paths_cost_temporary_bar_https,
             GetOriginUsage(quota_client.get(),
                            "https://bar.com/",
                            kTemporary));
 }
 
-}  // namespace fileapi
+}  // namespace content