Change how the quota system computes the total poolsize for temporary storage

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 "content/browser/appcache/appcache_storage_impl.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <stack>
@@ skipping 259 matching lines @@
     AppCacheStorageImplTest* test_;
   };
 
   class MockQuotaManager : public storage::QuotaManager {
    public:
     MockQuotaManager()
         : QuotaManager(true /* is_incognito */,
                        base::FilePath(),
                        io_thread->task_runner().get(),
                        db_thread->task_runner().get(),
-                       NULL),
+                       nullptr,
+                       storage::GetTemporaryStorageConfigurationFunc()),
           async_(false) {}
 
     void GetUsageAndQuota(const GURL& origin,
                           storage::StorageType type,
-                          const GetUsageAndQuotaCallback& callback) override {
+                          const UsageAndQuotaCallback& callback) override {
       EXPECT_EQ(storage::kStorageTypeTemporary, type);
       if (async_) {
         base::ThreadTaskRunnerHandle::Get()->PostTask(
             FROM_HERE, base::Bind(&MockQuotaManager::CallCallback,
                                   base::Unretained(this), callback));
         return;
       }
       CallCallback(callback);
     }
 
-    void CallCallback(const GetUsageAndQuotaCallback& callback) {
+    void CallCallback(const UsageAndQuotaCallback& callback) {
       callback.Run(storage::kQuotaStatusOk, 0, kMockQuota);
     }
 
     bool async_;
 
    protected:
     ~MockQuotaManager() override {}
   };
 
   class MockQuotaManagerProxy : public storage::QuotaManagerProxy {
@@ skipping 31 matching lines @@
     void RegisterClient(storage::QuotaClient* client) override {}
     void NotifyOriginInUse(const GURL& origin) override {}
     void NotifyOriginNoLongerInUse(const GURL& origin) override {}
     void SetUsageCacheEnabled(storage::QuotaClient::ID client_id,
                               const GURL& origin,
                               storage::StorageType type,
                               bool enabled) override {}
     void GetUsageAndQuota(base::SequencedTaskRunner* original_task_runner,
                           const GURL& origin,
                           storage::StorageType type,
-                          const GetUsageAndQuotaCallback& callback) override {}
+                          const UsageAndQuotaCallback& callback) override {}
 
     int notify_storage_accessed_count_;
     int notify_storage_modified_count_;
     GURL last_origin_;
     int last_delta_;
     scoped_refptr<MockQuotaManager> mock_manager_;
 
    protected:
     ~MockQuotaManagerProxy() override {}
   };
@@ skipping 1668 matching lines @@
   RunTestOnIOThread(&AppCacheStorageImplTest::Reinitialize2);
 }
 
 TEST_F(AppCacheStorageImplTest, Reinitialize3) {
   RunTestOnIOThread(&AppCacheStorageImplTest::Reinitialize3);
 }
 
 // That's all folks!
 
 }  // namespace content