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

chrome/browser/browsing_data/browsing_data_quota_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/files/scoped_temp_dir.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 16 matching lines @@
 
   BrowsingDataQuotaHelperTest()
       : fetching_completed_(true),
         quota_(-1),
         weak_factory_(this) {}
 
   virtual ~BrowsingDataQuotaHelperTest() {}
 
   virtual void SetUp() OVERRIDE {
     EXPECT_TRUE(dir_.CreateUniqueTempDir());
-    quota_manager_ = new quota::QuotaManager(
+    quota_manager_ = new storage::QuotaManager(
         false,
         dir_.path(),
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO).get(),
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::DB).get(),
         NULL);
     helper_ = new BrowsingDataQuotaHelperImpl(
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI).get(),
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO).get(),
         quota_manager_.get());
   }
@@ skipping 16 matching lines @@
 
   void StartFetching() {
     fetching_completed_ = false;
     helper_->StartFetching(
         base::Bind(&BrowsingDataQuotaHelperTest::FetchCompleted,
                    weak_factory_.GetWeakPtr()));
   }
 
   void RegisterClient(const MockOriginData* data, std::size_t data_len) {
     MockStorageClient* client =
-        new MockStorageClient(
-            quota_manager_->proxy(), data, quota::QuotaClient::kFileSystem,
-            data_len);
+        new MockStorageClient(quota_manager_->proxy(),
+                              data,
+                              storage::QuotaClient::kFileSystem,
+                              data_len);
     quota_manager_->proxy()->RegisterClient(client);
     client->TouchAllOriginsAndNotify();
   }
 
   void SetPersistentHostQuota(const std::string& host, int64 quota) {
     quota_ = -1;
     quota_manager_->SetPersistentHostQuota(
         host, quota,
         base::Bind(&BrowsingDataQuotaHelperTest::GotPersistentHostQuota,
                    weak_factory_.GetWeakPtr()));
   }
 
   void GetPersistentHostQuota(const std::string& host) {
     quota_ = -1;
     quota_manager_->GetPersistentHostQuota(
         host,
         base::Bind(&BrowsingDataQuotaHelperTest::GotPersistentHostQuota,
                    weak_factory_.GetWeakPtr()));
   }
 
-  void GotPersistentHostQuota(quota::QuotaStatusCode status,
-                              int64 quota) {
-    EXPECT_EQ(quota::kQuotaStatusOk, status);
+  void GotPersistentHostQuota(storage::QuotaStatusCode status, int64 quota) {
+    EXPECT_EQ(storage::kQuotaStatusOk, status);
     quota_ = quota;
   }
 
   void RevokeHostQuota(const std::string& host) {
     helper_->RevokeHostQuota(host);
   }
 
   int64 quota() {
     return quota_;
   }
 
  private:
   void FetchCompleted(const QuotaInfoArray& quota_info) {
     quota_info_ = quota_info;
     fetching_completed_ = true;
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
-  scoped_refptr<quota::QuotaManager> quota_manager_;
+  scoped_refptr<storage::QuotaManager> quota_manager_;
 
   base::ScopedTempDir dir_;
   scoped_refptr<BrowsingDataQuotaHelper> helper_;
 
   bool fetching_completed_;
   QuotaInfoArray quota_info_;
   int64 quota_;
   base::WeakPtrFactory<BrowsingDataQuotaHelperTest> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BrowsingDataQuotaHelperTest);
 };
 
 TEST_F(BrowsingDataQuotaHelperTest, Empty) {
   StartFetching();
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_TRUE(fetching_completed());
   EXPECT_TRUE(quota_info().empty());
 }
 
 TEST_F(BrowsingDataQuotaHelperTest, FetchData) {
   const MockOriginData kOrigins[] = {
-    {"http://example.com/", quota::kStorageTypeTemporary, 1},
-    {"https://example.com/", quota::kStorageTypeTemporary, 10},
-    {"http://example.com/", quota::kStorageTypePersistent, 100},
-    {"https://example.com/", quota::kStorageTypeSyncable, 1},
-    {"http://example2.com/", quota::kStorageTypeTemporary, 1000},
+      {"http://example.com/", storage::kStorageTypeTemporary, 1},
+      {"https://example.com/", storage::kStorageTypeTemporary, 10},
+      {"http://example.com/", storage::kStorageTypePersistent, 100},
+      {"https://example.com/", storage::kStorageTypeSyncable, 1},
+      {"http://example2.com/", storage::kStorageTypeTemporary, 1000},
   };
 
   RegisterClient(kOrigins, arraysize(kOrigins));
   StartFetching();
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_TRUE(fetching_completed());
 
   std::set<QuotaInfo> expected, actual;
   actual.insert(quota_info().begin(), quota_info().end());
   expected.insert(QuotaInfo("example.com", 11, 100, 1));
   expected.insert(QuotaInfo("example2.com", 1000, 0, 0));
   EXPECT_TRUE(expected == actual);
 }
 
 TEST_F(BrowsingDataQuotaHelperTest, IgnoreExtensionsAndDevTools) {
   const MockOriginData kOrigins[] = {
-    {"http://example.com/", quota::kStorageTypeTemporary, 1},
-    {"https://example.com/", quota::kStorageTypeTemporary, 10},
-    {"http://example.com/", quota::kStorageTypePersistent, 100},
-    {"https://example.com/", quota::kStorageTypeSyncable, 1},
-    {"http://example2.com/", quota::kStorageTypeTemporary, 1000},
-    {"chrome-extension://abcdefghijklmnopqrstuvwxyz/",
-        quota::kStorageTypeTemporary, 10000},
-    {"chrome-extension://abcdefghijklmnopqrstuvwxyz/",
-        quota::kStorageTypePersistent, 100000},
-    {"chrome-devtools://abcdefghijklmnopqrstuvwxyz/",
-        quota::kStorageTypeTemporary, 10000},
-    {"chrome-devtools://abcdefghijklmnopqrstuvwxyz/",
-        quota::kStorageTypePersistent, 100000},
+      {"http://example.com/", storage::kStorageTypeTemporary, 1},
+      {"https://example.com/", storage::kStorageTypeTemporary, 10},
+      {"http://example.com/", storage::kStorageTypePersistent, 100},
+      {"https://example.com/", storage::kStorageTypeSyncable, 1},
+      {"http://example2.com/", storage::kStorageTypeTemporary, 1000},
+      {"chrome-extension://abcdefghijklmnopqrstuvwxyz/",
+       storage::kStorageTypeTemporary, 10000},
+      {"chrome-extension://abcdefghijklmnopqrstuvwxyz/",
+       storage::kStorageTypePersistent, 100000},
+      {"chrome-devtools://abcdefghijklmnopqrstuvwxyz/",
+       storage::kStorageTypeTemporary, 10000},
+      {"chrome-devtools://abcdefghijklmnopqrstuvwxyz/",
+       storage::kStorageTypePersistent, 100000},
   };
 
   RegisterClient(kOrigins, arraysize(kOrigins));
   StartFetching();
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_TRUE(fetching_completed());
 
   std::set<QuotaInfo> expected, actual;
   actual.insert(quota_info().begin(), quota_info().end());
   expected.insert(QuotaInfo("example.com", 11, 100, 1));
@@ skipping 13 matching lines @@
   base::MessageLoop::current()->RunUntilIdle();
 
   GetPersistentHostQuota(kHost1);
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(0, quota());
 
   GetPersistentHostQuota(kHost2);
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(10, quota());
 }