[Quota] Add UsageTracker::GetGlobalLimitedUsage

webkit/quota/quota_temporary_storage_evictor_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 <list>
 #include <map>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/quota/mock_storage_client.h"
 #include "webkit/quota/quota_manager.h"
 #include "webkit/quota/quota_temporary_storage_evictor.h"
 
 namespace quota {
 
 class QuotaTemporaryStorageEvictorTest;
 
 namespace {
 
 class MockQuotaEvictionHandler : public quota::QuotaEvictionHandler {
  public:
   explicit MockQuotaEvictionHandler(QuotaTemporaryStorageEvictorTest *test)
       : quota_(0),
-        unlimited_usage_(0),
         available_space_(0),
         error_on_evict_origin_data_(false),
         error_on_get_usage_and_quota_(false) {}
 
   virtual void EvictOriginData(
       const GURL& origin,
       StorageType type,
       const EvictOriginDataCallback& callback) OVERRIDE {
     if (error_on_evict_origin_data_) {
       callback.Run(quota::kQuotaErrorInvalidModification);
       return;
     }
     int64 origin_usage = EnsureOriginRemoved(origin);
     if (origin_usage >= 0)
       available_space_ += origin_usage;
     callback.Run(quota::kQuotaStatusOk);
   }
 
   virtual void GetUsageAndQuotaForEviction(
       const UsageAndQuotaCallback& callback) OVERRIDE {
     if (error_on_get_usage_and_quota_) {
       callback.Run(quota::kQuotaErrorInvalidAccess, UsageAndQuota());
       return;
     }
     if (!task_for_get_usage_and_quota_.is_null())
       task_for_get_usage_and_quota_.Run();
-    UsageAndQuota quota_and_usage(
-        0, GetUsage(), unlimited_usage_, quota_, available_space_);
+    UsageAndQuota quota_and_usage(-1, GetUsage(), quota_, available_space_);
     callback.Run(quota::kQuotaStatusOk, quota_and_usage);
   }
 
   virtual void GetLRUOrigin(
       StorageType type,
       const GetLRUOriginCallback& callback) OVERRIDE {
     if (origin_order_.empty())
       callback.Run(GURL());
     else
       callback.Run(GURL(origin_order_.front()));
   }
 
   int64 GetUsage() const {
     int64 total_usage = 0;
     for (std::map<GURL, int64>::const_iterator p = origins_.begin();
          p != origins_.end();
          ++p)
       total_usage += p->second;
     return total_usage;
   }
 
   void set_quota(int64 quota) {
     quota_ = quota;
   }
-  void set_unlimited_usage(int64 usage) {
-    unlimited_usage_ = usage;
-  }
   void set_available_space(int64 available_space) {
     available_space_ = available_space;
   }
   void set_task_for_get_usage_and_quota(const base::Closure& task) {
     task_for_get_usage_and_quota_= task;
   }
   void set_error_on_evict_origin_data(bool error_on_evict_origin_data) {
     error_on_evict_origin_data_ = error_on_evict_origin_data;
   }
   void set_error_on_get_usage_and_quota(bool error_on_get_usage_and_quota) {
@@ skipping 24 matching lines @@
       return -1;
     else
       origin_usage = origins_[origin];
 
     origins_.erase(origin);
     origin_order_.remove(origin);
     return origin_usage;
   }
 
   int64 quota_;
-  int64 unlimited_usage_;
   int64 available_space_;
   std::list<GURL> origin_order_;
   std::map<GURL, int64> origins_;
   bool error_on_evict_origin_data_;
   bool error_on_get_usage_and_quota_;
 
   base::Closure task_for_get_usage_and_quota_;
 };
 
 }  // anonymous namespace
@@ skipping 265 matching lines @@
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(150 + 300, quota_eviction_handler()->GetUsage());
 
   EXPECT_EQ(0, statistics().num_errors_on_evicting_origin);
   EXPECT_EQ(0, statistics().num_errors_on_getting_usage_and_quota);
   EXPECT_EQ(2, statistics().num_evicted_origins);
   EXPECT_EQ(1, statistics().num_eviction_rounds);
   EXPECT_EQ(0, statistics().num_skipped_eviction_rounds);
 }
 
-TEST_F(QuotaTemporaryStorageEvictorTest, UnlimitedExclusionEvictionTest) {
-  quota_eviction_handler()->AddOrigin(GURL("http://www.z.com"), 3000);
-  quota_eviction_handler()->AddOrigin(GURL("http://www.y.com"), 200);
-  quota_eviction_handler()->AddOrigin(GURL("http://www.x.com"), 500000);
-  quota_eviction_handler()->set_unlimited_usage(500000);
-  quota_eviction_handler()->set_quota(5000);
-  quota_eviction_handler()->set_available_space(1000000000);
-  EXPECT_EQ(3000 + 200 + 500000, quota_eviction_handler()->GetUsage());
-  set_repeated_eviction(false);
-  temporary_storage_evictor()->Start();
-  base::MessageLoop::current()->RunUntilIdle();
-  // Nothing should have been evicted.
-  EXPECT_EQ(3000 + 200 + 500000, quota_eviction_handler()->GetUsage());
-}
-
 }  // namespace quota