src/content/browser/appcache/appcache_storage_unittest.cc

   1 // Copyright 2014 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/message_loop/message_loop.h"
   6 #include "content/browser/appcache/mock_appcache_service.h"
   7 #include "content/browser/quota/mock_quota_manager_proxy.h"
   8 #include "testing/gtest/include/gtest/gtest.h"
   9 #include "webkit/browser/appcache/appcache.h"
  10 #include "webkit/browser/appcache/appcache_group.h"
  11 #include "webkit/browser/appcache/appcache_response.h"
  12 #include "webkit/browser/appcache/appcache_storage.h"
  13
  14 using appcache::AppCache;
  15 using appcache::AppCacheGroup;
  16 using appcache::AppCacheResponseInfo;
  17 using appcache::AppCacheStorage;
  18 using appcache::kUnkownResponseDataSize;
  19
  20 namespace content {
  21
  22 namespace {
  23 const quota::StorageType kTemp = quota::kStorageTypeTemporary;
  24 }
  25
  26 class AppCacheStorageTest : public testing::Test {
  27  public:
  28   class MockStorageDelegate : public AppCacheStorage::Delegate {
  29    public:
  30   };
  31 };
  32
  33 TEST_F(AppCacheStorageTest, AddRemoveCache) {
  34   MockAppCacheService service;
  35   scoped_refptr<AppCache> cache(new AppCache(service.storage(), 111));
  36
  37   EXPECT_EQ(cache.get(),
  38             service.storage()->working_set()->GetCache(111));
  39
  40   service.storage()->working_set()->RemoveCache(cache.get());
  41
  42   EXPECT_TRUE(!service.storage()->working_set()->GetCache(111));
  43
  44   // Removing non-existing cache from service should not fail.
  45   MockAppCacheService dummy;
  46   dummy.storage()->working_set()->RemoveCache(cache.get());
  47 }
  48
  49 TEST_F(AppCacheStorageTest, AddRemoveGroup) {
  50   MockAppCacheService service;
  51   scoped_refptr<AppCacheGroup> group(
  52       new AppCacheGroup(service.storage(), GURL(), 111));
  53
  54   EXPECT_EQ(group.get(), service.storage()->working_set()->GetGroup(GURL()));
  55
  56   service.storage()->working_set()->RemoveGroup(group.get());
  57
  58   EXPECT_TRUE(!service.storage()->working_set()->GetGroup(GURL()));
  59
  60   // Removing non-existing group from service should not fail.
  61   MockAppCacheService dummy;
  62   dummy.storage()->working_set()->RemoveGroup(group.get());
  63 }
  64
  65 TEST_F(AppCacheStorageTest, AddRemoveResponseInfo) {
  66   MockAppCacheService service;
  67   scoped_refptr<AppCacheResponseInfo> info(
  68       new AppCacheResponseInfo(service.storage(), GURL(),
  69                                111, new net::HttpResponseInfo,
  70                                kUnkownResponseDataSize));
  71
  72   EXPECT_EQ(info.get(),
  73             service.storage()->working_set()->GetResponseInfo(111));
  74
  75   service.storage()->working_set()->RemoveResponseInfo(info.get());
  76
  77   EXPECT_TRUE(!service.storage()->working_set()->GetResponseInfo(111));
  78
  79   // Removing non-existing info from service should not fail.
  80   MockAppCacheService dummy;
  81   dummy.storage()->working_set()->RemoveResponseInfo(info.get());
  82 }
  83
  84 TEST_F(AppCacheStorageTest, DelegateReferences) {
  85   typedef scoped_refptr<AppCacheStorage::DelegateReference>
  86       ScopedDelegateReference;
  87   MockAppCacheService service;
  88   MockStorageDelegate delegate;
  89   ScopedDelegateReference delegate_reference1;
  90   ScopedDelegateReference delegate_reference2;
  91
  92   EXPECT_FALSE(service.storage()->GetDelegateReference(&delegate));
  93
  94   delegate_reference1 =
  95       service.storage()->GetOrCreateDelegateReference(&delegate);
  96   EXPECT_TRUE(delegate_reference1.get());
  97   EXPECT_TRUE(delegate_reference1->HasOneRef());
  98   EXPECT_TRUE(service.storage()->GetDelegateReference(&delegate));
  99   EXPECT_EQ(&delegate,
 100             service.storage()->GetDelegateReference(&delegate)->delegate);
 101   EXPECT_EQ(service.storage()->GetDelegateReference(&delegate),
 102             service.storage()->GetOrCreateDelegateReference(&delegate));
 103   delegate_reference1 = NULL;
 104   EXPECT_FALSE(service.storage()->GetDelegateReference(&delegate));
 105
 106   delegate_reference1 =
 107       service.storage()->GetOrCreateDelegateReference(&delegate);
 108   service.storage()->CancelDelegateCallbacks(&delegate);
 109   EXPECT_TRUE(delegate_reference1.get());
 110   EXPECT_TRUE(delegate_reference1->HasOneRef());
 111   EXPECT_FALSE(delegate_reference1->delegate);
 112   EXPECT_FALSE(service.storage()->GetDelegateReference(&delegate));
 113
 114   delegate_reference2 =
 115       service.storage()->GetOrCreateDelegateReference(&delegate);
 116   EXPECT_TRUE(delegate_reference2.get());
 117   EXPECT_TRUE(delegate_reference2->HasOneRef());
 118   EXPECT_EQ(&delegate, delegate_reference2->delegate);
 119   EXPECT_NE(delegate_reference1.get(), delegate_reference2.get());
 120 }
 121
 122 TEST_F(AppCacheStorageTest, UsageMap) {
 123   const GURL kOrigin("http://origin/");
 124   const GURL kOrigin2("http://origin2/");
 125
 126   MockAppCacheService service;
 127   scoped_refptr<MockQuotaManagerProxy> mock_proxy(
 128       new MockQuotaManagerProxy(NULL, NULL));
 129   service.set_quota_manager_proxy(mock_proxy.get());
 130
 131   service.storage()->UpdateUsageMapAndNotify(kOrigin, 0);
 132   EXPECT_EQ(0, mock_proxy->notify_storage_modified_count());
 133
 134   service.storage()->UpdateUsageMapAndNotify(kOrigin, 10);
 135   EXPECT_EQ(1, mock_proxy->notify_storage_modified_count());
 136   EXPECT_EQ(10, mock_proxy->last_notified_delta());
 137   EXPECT_EQ(kOrigin, mock_proxy->last_notified_origin());
 138   EXPECT_EQ(kTemp, mock_proxy->last_notified_type());
 139
 140   service.storage()->UpdateUsageMapAndNotify(kOrigin, 100);
 141   EXPECT_EQ(2, mock_proxy->notify_storage_modified_count());
 142   EXPECT_EQ(90, mock_proxy->last_notified_delta());
 143   EXPECT_EQ(kOrigin, mock_proxy->last_notified_origin());
 144   EXPECT_EQ(kTemp, mock_proxy->last_notified_type());
 145
 146   service.storage()->UpdateUsageMapAndNotify(kOrigin, 0);
 147   EXPECT_EQ(3, mock_proxy->notify_storage_modified_count());
 148   EXPECT_EQ(-100, mock_proxy->last_notified_delta());
 149   EXPECT_EQ(kOrigin, mock_proxy->last_notified_origin());
 150   EXPECT_EQ(kTemp, mock_proxy->last_notified_type());
 151
 152   service.storage()->NotifyStorageAccessed(kOrigin2);
 153   EXPECT_EQ(0, mock_proxy->notify_storage_accessed_count());
 154
 155   service.storage()->usage_map_[kOrigin2] = 1;
 156   service.storage()->NotifyStorageAccessed(kOrigin2);
 157   EXPECT_EQ(1, mock_proxy->notify_storage_accessed_count());
 158   EXPECT_EQ(kOrigin2, mock_proxy->last_notified_origin());
 159   EXPECT_EQ(kTemp, mock_proxy->last_notified_type());
 160
 161   service.storage()->usage_map_.clear();
 162   service.storage()->usage_map_[kOrigin] = 5000;
 163   service.storage()->ClearUsageMapAndNotify();
 164   EXPECT_EQ(4, mock_proxy->notify_storage_modified_count());
 165   EXPECT_EQ(-5000, mock_proxy->last_notified_delta());
 166   EXPECT_EQ(kOrigin, mock_proxy->last_notified_origin());
 167   EXPECT_EQ(kTemp, mock_proxy->last_notified_type());
 168   EXPECT_TRUE(service.storage()->usage_map_.empty());
 169 }
 170
 171 }  // namespace content