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

content/browser/appcache/appcache_storage_impl_unittest.cc

 // Copyright 2014 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 <stack>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/file_util.h"
@@ skipping 233 matching lines @@
     GURL found_url_;
     AppCacheEntry found_entry_;
     GURL found_namespace_entry_url_;
     AppCacheEntry found_fallback_entry_;
     int64 found_cache_id_;
     int64 found_group_id_;
     GURL found_manifest_url_;
     AppCacheStorageImplTest* test_;
   };
 
-  class MockQuotaManager : public quota::QuotaManager {
+  class MockQuotaManager : public storage::QuotaManager {
    public:
     MockQuotaManager()
         : QuotaManager(true /* is_incognito */,
                        base::FilePath(),
                        io_thread->message_loop_proxy().get(),
                        db_thread->message_loop_proxy().get(),
                        NULL),
           async_(false) {}
 
     virtual void GetUsageAndQuota(
         const GURL& origin,
-        quota::StorageType type,
+        storage::StorageType type,
         const GetUsageAndQuotaCallback& callback) OVERRIDE {
-      EXPECT_EQ(quota::kStorageTypeTemporary, type);
+      EXPECT_EQ(storage::kStorageTypeTemporary, type);
       if (async_) {
         base::MessageLoop::current()->PostTask(
             FROM_HERE,
             base::Bind(&MockQuotaManager::CallCallback,
                        base::Unretained(this),
                        callback));
         return;
       }
       CallCallback(callback);
     }
 
     void CallCallback(const GetUsageAndQuotaCallback& callback) {
-      callback.Run(quota::kQuotaStatusOk, 0, kMockQuota);
+      callback.Run(storage::kQuotaStatusOk, 0, kMockQuota);
     }
 
     bool async_;
 
    protected:
     virtual ~MockQuotaManager() {}
   };
 
-  class MockQuotaManagerProxy : public quota::QuotaManagerProxy {
+  class MockQuotaManagerProxy : public storage::QuotaManagerProxy {
    public:
     MockQuotaManagerProxy()
         : QuotaManagerProxy(NULL, NULL),
           notify_storage_accessed_count_(0),
           notify_storage_modified_count_(0),
           last_delta_(0),
           mock_manager_(new MockQuotaManager) {
       manager_ = mock_manager_.get();
     }
 
-    virtual void NotifyStorageAccessed(quota::QuotaClient::ID client_id,
+    virtual void NotifyStorageAccessed(storage::QuotaClient::ID client_id,
                                        const GURL& origin,
-                                       quota::StorageType type) OVERRIDE {
-      EXPECT_EQ(quota::QuotaClient::kAppcache, client_id);
-      EXPECT_EQ(quota::kStorageTypeTemporary, type);
+                                       storage::StorageType type) OVERRIDE {
+      EXPECT_EQ(storage::QuotaClient::kAppcache, client_id);
+      EXPECT_EQ(storage::kStorageTypeTemporary, type);
       ++notify_storage_accessed_count_;
       last_origin_ = origin;
     }
 
-    virtual void NotifyStorageModified(quota::QuotaClient::ID client_id,
+    virtual void NotifyStorageModified(storage::QuotaClient::ID client_id,
                                        const GURL& origin,
-                                       quota::StorageType type,
+                                       storage::StorageType type,
                                        int64 delta) OVERRIDE {
-      EXPECT_EQ(quota::QuotaClient::kAppcache, client_id);
-      EXPECT_EQ(quota::kStorageTypeTemporary, type);
+      EXPECT_EQ(storage::QuotaClient::kAppcache, client_id);
+      EXPECT_EQ(storage::kStorageTypeTemporary, type);
       ++notify_storage_modified_count_;
       last_origin_ = origin;
       last_delta_ = delta;
     }
 
     // Not needed for our tests.
-    virtual void RegisterClient(quota::QuotaClient* client) OVERRIDE {}
+    virtual void RegisterClient(storage::QuotaClient* client) OVERRIDE {}
     virtual void NotifyOriginInUse(const GURL& origin) OVERRIDE {}
     virtual void NotifyOriginNoLongerInUse(const GURL& origin) OVERRIDE {}
-    virtual void SetUsageCacheEnabled(quota::QuotaClient::ID client_id,
+    virtual void SetUsageCacheEnabled(storage::QuotaClient::ID client_id,
                                       const GURL& origin,
-                                      quota::StorageType type,
+                                      storage::StorageType type,
                                       bool enabled) OVERRIDE {}
     virtual void GetUsageAndQuota(
         base::SequencedTaskRunner* original_task_runner,
         const GURL& origin,
-        quota::StorageType type,
+        storage::StorageType type,
         const GetUsageAndQuotaCallback& callback) OVERRIDE {}
 
     int notify_storage_accessed_count_;
     int notify_storage_modified_count_;
     GURL last_origin_;
     int last_delta_;
     scoped_refptr<MockQuotaManager> mock_manager_;
 
    protected:
     virtual ~MockQuotaManagerProxy() {}
@@ skipping 1673 matching lines @@
   RunTestOnIOThread(&AppCacheStorageImplTest::Reinitialize2);
 }
 
 TEST_F(AppCacheStorageImplTest, Reinitialize3) {
   RunTestOnIOThread(&AppCacheStorageImplTest::Reinitialize3);
 }
 
 // That's all folks!
 
 }  // namespace content