src/webkit/browser/quota/usage_tracker_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/bind.h"
   6 #include "base/run_loop.h"
   7 #include "net/base/net_util.h"
   8 #include "testing/gtest/include/gtest/gtest.h"
   9 #include "webkit/browser/quota/mock_special_storage_policy.h"
  10 #include "webkit/browser/quota/usage_tracker.h"
  11
  12 namespace quota {
  13
  14 namespace {
  15
  16 void DidGetGlobalUsage(bool* done,
  17                        int64* usage_out,
  18                        int64* unlimited_usage_out,
  19                        int64 usage,
  20                        int64 unlimited_usage) {
  21   EXPECT_FALSE(*done);
  22   *done = true;
  23   *usage_out = usage;
  24   *unlimited_usage_out = unlimited_usage;
  25 }
  26
  27 void DidGetUsage(bool* done,
  28                  int64* usage_out,
  29                  int64 usage) {
  30   EXPECT_FALSE(*done);
  31   *done = true;
  32   *usage_out = usage;
  33 }
  34
  35 }  // namespace
  36
  37 class MockQuotaClient : public QuotaClient {
  38  public:
  39   MockQuotaClient() {}
  40   virtual ~MockQuotaClient() {}
  41
  42   virtual ID id() const OVERRIDE {
  43     return kFileSystem;
  44   }
  45
  46   virtual void OnQuotaManagerDestroyed() OVERRIDE {}
  47
  48   virtual void GetOriginUsage(const GURL& origin,
  49                               StorageType type,
  50                               const GetUsageCallback& callback) OVERRIDE {
  51     EXPECT_EQ(kStorageTypeTemporary, type);
  52     int64 usage = GetUsage(origin);
  53     base::MessageLoop::current()->PostTask(FROM_HERE,
  54                                            base::Bind(callback, usage));
  55   }
  56
  57   virtual void GetOriginsForType(StorageType type,
  58                                  const GetOriginsCallback& callback) OVERRIDE {
  59     EXPECT_EQ(kStorageTypeTemporary, type);
  60     std::set<GURL> origins;
  61     for (UsageMap::const_iterator itr = usage_map_.begin();
  62          itr != usage_map_.end(); ++itr) {
  63       origins.insert(itr->first);
  64     }
  65     base::MessageLoop::current()->PostTask(FROM_HERE,
  66                                            base::Bind(callback, origins));
  67   }
  68
  69   virtual void GetOriginsForHost(StorageType type,
  70                                  const std::string& host,
  71                                  const GetOriginsCallback& callback) OVERRIDE {
  72     EXPECT_EQ(kStorageTypeTemporary, type);
  73     std::set<GURL> origins;
  74     for (UsageMap::const_iterator itr = usage_map_.begin();
  75          itr != usage_map_.end(); ++itr) {
  76       if (net::GetHostOrSpecFromURL(itr->first) == host)
  77         origins.insert(itr->first);
  78     }
  79     base::MessageLoop::current()->PostTask(FROM_HERE,
  80                                            base::Bind(callback, origins));
  81   }
  82
  83   virtual void DeleteOriginData(const GURL& origin,
  84                                 StorageType type,
  85                                 const DeletionCallback& callback) OVERRIDE {
  86     EXPECT_EQ(kStorageTypeTemporary, type);
  87     usage_map_.erase(origin);
  88     base::MessageLoop::current()->PostTask(
  89         FROM_HERE, base::Bind(callback, kQuotaStatusOk));
  90   }
  91
  92   virtual bool DoesSupport(quota::StorageType type) const OVERRIDE {
  93     return type == quota::kStorageTypeTemporary;
  94   }
  95
  96   int64 GetUsage(const GURL& origin) {
  97     UsageMap::const_iterator found = usage_map_.find(origin);
  98     if (found == usage_map_.end())
  99       return 0;
 100     return found->second;
 101   }
 102
 103   void SetUsage(const GURL& origin, int64 usage) {
 104     usage_map_[origin] = usage;
 105   }
 106
 107   int64 UpdateUsage(const GURL& origin, int64 delta) {
 108     return usage_map_[origin] += delta;
 109   }
 110
 111  private:
 112   typedef std::map<GURL, int64> UsageMap;
 113
 114   UsageMap usage_map_;
 115
 116   DISALLOW_COPY_AND_ASSIGN(MockQuotaClient);
 117 };
 118
 119 class UsageTrackerTest : public testing::Test {
 120  public:
 121   UsageTrackerTest()
 122       : storage_policy_(new MockSpecialStoragePolicy()),
 123         usage_tracker_(GetUsageTrackerList(), kStorageTypeTemporary,
 124                        storage_policy_.get()) {
 125   }
 126
 127   virtual ~UsageTrackerTest() {}
 128
 129   UsageTracker* usage_tracker() {
 130     return &usage_tracker_;
 131   }
 132
 133   void UpdateUsage(const GURL& origin, int64 delta) {
 134     quota_client_.UpdateUsage(origin, delta);
 135     usage_tracker_.UpdateUsageCache(quota_client_.id(), origin, delta);
 136     base::RunLoop().RunUntilIdle();
 137   }
 138
 139   void UpdateUsageWithoutNotification(const GURL& origin, int64 delta) {
 140     quota_client_.UpdateUsage(origin, delta);
 141   }
 142
 143   void GetGlobalLimitedUsage(int64* limited_usage) {
 144     bool done = false;
 145     usage_tracker_.GetGlobalLimitedUsage(base::Bind(
 146         &DidGetUsage, &done, limited_usage));
 147     base::RunLoop().RunUntilIdle();
 148
 149     EXPECT_TRUE(done);
 150   }
 151
 152   void GetGlobalUsage(int64* usage, int64* unlimited_usage) {
 153     bool done = false;
 154     usage_tracker_.GetGlobalUsage(base::Bind(
 155         &DidGetGlobalUsage,
 156         &done, usage, unlimited_usage));
 157     base::RunLoop().RunUntilIdle();
 158
 159     EXPECT_TRUE(done);
 160   }
 161
 162   void GetHostUsage(const std::string& host, int64* usage) {
 163     bool done = false;
 164     usage_tracker_.GetHostUsage(host, base::Bind(&DidGetUsage, &done, usage));
 165     base::RunLoop().RunUntilIdle();
 166
 167     EXPECT_TRUE(done);
 168   }
 169
 170   void GrantUnlimitedStoragePolicy(const GURL& origin) {
 171     if (!storage_policy_->IsStorageUnlimited(origin)) {
 172       storage_policy_->AddUnlimited(origin);
 173       storage_policy_->NotifyGranted(
 174           origin, SpecialStoragePolicy::STORAGE_UNLIMITED);
 175     }
 176   }
 177
 178   void RevokeUnlimitedStoragePolicy(const GURL& origin) {
 179     if (storage_policy_->IsStorageUnlimited(origin)) {
 180       storage_policy_->RemoveUnlimited(origin);
 181       storage_policy_->NotifyRevoked(
 182           origin, SpecialStoragePolicy::STORAGE_UNLIMITED);
 183     }
 184   }
 185
 186   void SetUsageCacheEnabled(const GURL& origin, bool enabled) {
 187     usage_tracker_.SetUsageCacheEnabled(
 188         quota_client_.id(), origin, enabled);
 189   }
 190
 191  private:
 192   QuotaClientList GetUsageTrackerList() {
 193     QuotaClientList client_list;
 194     client_list.push_back(&quota_client_);
 195     return client_list;
 196   }
 197
 198   base::MessageLoop message_loop_;
 199
 200   scoped_refptr<MockSpecialStoragePolicy> storage_policy_;
 201   MockQuotaClient quota_client_;
 202   UsageTracker usage_tracker_;
 203
 204   DISALLOW_COPY_AND_ASSIGN(UsageTrackerTest);
 205 };
 206
 207 TEST_F(UsageTrackerTest, GrantAndRevokeUnlimitedStorage) {
 208   int64 usage = 0;
 209   int64 unlimited_usage = 0;
 210   int64 host_usage = 0;
 211   GetGlobalUsage(&usage, &unlimited_usage);
 212   EXPECT_EQ(0, usage);
 213   EXPECT_EQ(0, unlimited_usage);
 214
 215   const GURL origin("http://example.com");
 216   const std::string host(net::GetHostOrSpecFromURL(origin));
 217
 218   UpdateUsage(origin, 100);
 219   GetGlobalUsage(&usage, &unlimited_usage);
 220   GetHostUsage(host, &host_usage);
 221   EXPECT_EQ(100, usage);
 222   EXPECT_EQ(0, unlimited_usage);
 223   EXPECT_EQ(100, host_usage);
 224
 225   GrantUnlimitedStoragePolicy(origin);
 226   GetGlobalUsage(&usage, &unlimited_usage);
 227   GetHostUsage(host, &host_usage);
 228   EXPECT_EQ(100, usage);
 229   EXPECT_EQ(100, unlimited_usage);
 230   EXPECT_EQ(100, host_usage);
 231
 232   RevokeUnlimitedStoragePolicy(origin);
 233   GetGlobalUsage(&usage, &unlimited_usage);
 234   GetHostUsage(host, &host_usage);
 235   EXPECT_EQ(100, usage);
 236   EXPECT_EQ(0, unlimited_usage);
 237   EXPECT_EQ(100, host_usage);
 238 }
 239
 240 TEST_F(UsageTrackerTest, CacheDisabledClientTest) {
 241   int64 usage = 0;
 242   int64 unlimited_usage = 0;
 243   int64 host_usage = 0;
 244
 245   const GURL origin("http://example.com");
 246   const std::string host(net::GetHostOrSpecFromURL(origin));
 247
 248   UpdateUsage(origin, 100);
 249   GetGlobalUsage(&usage, &unlimited_usage);
 250   GetHostUsage(host, &host_usage);
 251   EXPECT_EQ(100, usage);
 252   EXPECT_EQ(0, unlimited_usage);
 253   EXPECT_EQ(100, host_usage);
 254
 255   UpdateUsageWithoutNotification(origin, 100);
 256   GetGlobalUsage(&usage, &unlimited_usage);
 257   GetHostUsage(host, &host_usage);
 258   EXPECT_EQ(100, usage);
 259   EXPECT_EQ(0, unlimited_usage);
 260   EXPECT_EQ(100, host_usage);
 261
 262   GrantUnlimitedStoragePolicy(origin);
 263   UpdateUsageWithoutNotification(origin, 100);
 264   SetUsageCacheEnabled(origin, false);
 265   UpdateUsageWithoutNotification(origin, 100);
 266
 267   GetGlobalUsage(&usage, &unlimited_usage);
 268   GetHostUsage(host, &host_usage);
 269   EXPECT_EQ(400, usage);
 270   EXPECT_EQ(400, unlimited_usage);
 271   EXPECT_EQ(400, host_usage);
 272
 273   RevokeUnlimitedStoragePolicy(origin);
 274   GetGlobalUsage(&usage, &unlimited_usage);
 275   GetHostUsage(host, &host_usage);
 276   EXPECT_EQ(400, usage);
 277   EXPECT_EQ(0, unlimited_usage);
 278   EXPECT_EQ(400, host_usage);
 279
 280   SetUsageCacheEnabled(origin, true);
 281   UpdateUsage(origin, 100);
 282
 283   GetGlobalUsage(&usage, &unlimited_usage);
 284   GetHostUsage(host, &host_usage);
 285   EXPECT_EQ(500, usage);
 286   EXPECT_EQ(0, unlimited_usage);
 287   EXPECT_EQ(500, host_usage);
 288 }
 289
 290 TEST_F(UsageTrackerTest, LimitedGlobalUsageTest) {
 291   const GURL kNormal("http://normal");
 292   const GURL kUnlimited("http://unlimited");
 293   const GURL kNonCached("http://non_cached");
 294   const GURL kNonCachedUnlimited("http://non_cached-unlimited");
 295
 296   GrantUnlimitedStoragePolicy(kUnlimited);
 297   GrantUnlimitedStoragePolicy(kNonCachedUnlimited);
 298
 299   SetUsageCacheEnabled(kNonCached, false);
 300   SetUsageCacheEnabled(kNonCachedUnlimited, false);
 301
 302   UpdateUsageWithoutNotification(kNormal, 1);
 303   UpdateUsageWithoutNotification(kUnlimited, 2);
 304   UpdateUsageWithoutNotification(kNonCached, 4);
 305   UpdateUsageWithoutNotification(kNonCachedUnlimited, 8);
 306
 307   int64 limited_usage = 0;
 308   int64 total_usage = 0;
 309   int64 unlimited_usage = 0;
 310
 311   GetGlobalLimitedUsage(&limited_usage);
 312   GetGlobalUsage(&total_usage, &unlimited_usage);
 313   EXPECT_EQ(1 + 4, limited_usage);
 314   EXPECT_EQ(1 + 2 + 4 + 8, total_usage);
 315   EXPECT_EQ(2 + 8, unlimited_usage);
 316
 317   UpdateUsageWithoutNotification(kNonCached, 16 - 4);
 318   UpdateUsageWithoutNotification(kNonCachedUnlimited, 32 - 8);
 319
 320   GetGlobalLimitedUsage(&limited_usage);
 321   GetGlobalUsage(&total_usage, &unlimited_usage);
 322   EXPECT_EQ(1 + 16, limited_usage);
 323   EXPECT_EQ(1 + 2 + 16 + 32, total_usage);
 324   EXPECT_EQ(2 + 32, unlimited_usage);
 325 }
 326
 327
 328 }  // namespace quota