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

content/browser/quota/storage_monitor_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 <stdint.h>
 
 #include <vector>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/run_loop.h"
@@ skipping 50 matching lines @@
 };
 
 // A mock quota manager for overriding GetUsageAndQuotaForWebApps().
 class UsageMockQuotaManager : public QuotaManager {
  public:
   UsageMockQuotaManager(SpecialStoragePolicy* special_storage_policy)
       : QuotaManager(false,
                      base::FilePath(),
                      base::ThreadTaskRunnerHandle::Get().get(),
                      base::ThreadTaskRunnerHandle::Get().get(),
-                     special_storage_policy,
-                     storage::GetQuotaSettingsFunc()),
+                     special_storage_policy),
         callback_usage_(0),
         callback_quota_(0),
         callback_status_(kQuotaStatusOk),
         initialized_(false) {}
 
   void SetCallbackParams(int64_t usage, int64_t quota, QuotaStatusCode status) {
     initialized_ = true;
     callback_quota_ = quota;
     callback_usage_ = usage;
     callback_status_ = status;
   }
 
   void InvokeCallback() {
     delayed_callback_.Run(callback_status_, callback_usage_, callback_quota_);
   }
 
   void GetUsageAndQuotaForWebApps(
       const GURL& origin,
       StorageType type,
-      const UsageAndQuotaCallback& callback) override {
+      const GetUsageAndQuotaCallback& callback) override {
     if (initialized_)
       callback.Run(callback_status_, callback_usage_, callback_quota_);
     else
       delayed_callback_ = callback;
   }
 
  protected:
   ~UsageMockQuotaManager() override {}
 
  private:
   int64_t callback_usage_;
   int64_t callback_quota_;
   QuotaStatusCode callback_status_;
   bool initialized_;
-  UsageAndQuotaCallback delayed_callback_;
+  GetUsageAndQuotaCallback delayed_callback_;
 };
 
 }  // namespace
 
 class StorageMonitorTestBase : public testing::Test {
  protected:
   void DispatchPendingEvents(StorageObserverList& observer_list) {
     observer_list.DispatchPendingEvent();
   }
 
@@ skipping 525 matching lines @@
 
 // Integration test for QuotaManager and StorageMonitor:
 
 class StorageMonitorIntegrationTest : public testing::Test {
  public:
   void SetUp() override {
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
     storage_policy_ = new MockSpecialStoragePolicy();
     quota_manager_ = new QuotaManager(
         false, data_dir_.GetPath(), base::ThreadTaskRunnerHandle::Get().get(),
-        base::ThreadTaskRunnerHandle::Get().get(), storage_policy_.get(),
-        storage::GetQuotaSettingsFunc());
+        base::ThreadTaskRunnerHandle::Get().get(), storage_policy_.get());
 
     client_ = new MockStorageClient(quota_manager_->proxy(),
                                     NULL,
                                     QuotaClient::kFileSystem,
                                     0);
 
     quota_manager_->proxy()->RegisterClient(client_);
   }
 
   void TearDown() override {
@@ skipping 31 matching lines @@
   base::RunLoop().RunUntilIdle();
 
   // Verify that the observer receives it.
   ASSERT_EQ(1, mock_observer.EventCount());
   const StorageObserver::Event& event = mock_observer.LastEvent();
   EXPECT_EQ(params.filter, event.filter);
   EXPECT_EQ(kTestUsage, event.usage);
 }
 
 }  // namespace content