chrome/browser/renderer_host/web_cache_manager_unittest.cc

   1 // Copyright (c) 2011 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 <string>
   6
   7 #include "base/message_loop.h"
   8 #include "chrome/browser/renderer_host/web_cache_manager.h"
   9 #include "content/public/test/test_browser_thread.h"
  10 #include "testing/gtest/include/gtest/gtest.h"
  11
  12 using base::Time;
  13 using base::TimeDelta;
  14 using content::BrowserThread;
  15 using WebKit::WebCache;
  16
  17 class WebCacheManagerTest : public testing::Test {
  18  protected:
  19   typedef WebCacheManager::StatsMap StatsMap;
  20   typedef WebCacheManager::Allocation Allocation;
  21   typedef WebCacheManager::AllocationStrategy AllocationStrategy;
  22
  23   static const int kRendererID;
  24   static const int kRendererID2;
  25   static const WebCache::UsageStats kStats;
  26   static const WebCache::UsageStats kStats2;
  27
  28   WebCacheManagerTest()
  29       : ui_thread_(BrowserThread::UI, &message_loop_) {
  30   }
  31
  32   // Thunks to access protected members of WebCacheManager
  33   static std::map<int, WebCacheManager::RendererInfo>& stats(
  34         WebCacheManager* h) {
  35     return h->stats_;
  36   }
  37
  38   static void SimulateInactivity(WebCacheManager* h, int renderer_id) {
  39     stats(h)[renderer_id].access = Time::Now() - TimeDelta::FromMinutes(
  40         WebCacheManager::kRendererInactiveThresholdMinutes);
  41     h->FindInactiveRenderers();
  42   }
  43
  44   static std::set<int>& active_renderers(WebCacheManager* h) {
  45     return h->active_renderers_;
  46   }
  47   static std::set<int>& inactive_renderers(WebCacheManager* h) {
  48     return h->inactive_renderers_;
  49   }
  50   static void GatherStats(WebCacheManager* h,
  51                           std::set<int> renderers,
  52                           WebCache::UsageStats* stats) {
  53     h->GatherStats(renderers, stats);
  54   }
  55   static size_t GetSize(int tactic,
  56                         const WebCache::UsageStats& stats) {
  57     return WebCacheManager::GetSize(
  58         static_cast<WebCacheManager::AllocationTactic>(tactic), stats);
  59   }
  60   static bool AttemptTactic(WebCacheManager* h,
  61                             int active_tactic,
  62                             const WebCache::UsageStats& active_stats,
  63                             int inactive_tactic,
  64                             const WebCache::UsageStats& inactive_stats,
  65                             std::list< std::pair<int,size_t> >* strategy) {
  66     return h->AttemptTactic(
  67         static_cast<WebCacheManager::AllocationTactic>(active_tactic),
  68         active_stats,
  69         static_cast<WebCacheManager::AllocationTactic>(inactive_tactic),
  70         inactive_stats,
  71         strategy);
  72   }
  73   static void AddToStrategy(WebCacheManager* h,
  74                             std::set<int> renderers,
  75                             int tactic,
  76                             size_t extra_bytes_to_allocate,
  77                             std::list< std::pair<int,size_t> >* strategy) {
  78     h->AddToStrategy(renderers,
  79                      static_cast<WebCacheManager::AllocationTactic>(tactic),
  80                      extra_bytes_to_allocate,
  81                      strategy);
  82   }
  83
  84   enum {
  85     DIVIDE_EVENLY = WebCacheManager::DIVIDE_EVENLY,
  86     KEEP_CURRENT_WITH_HEADROOM = WebCacheManager::KEEP_CURRENT_WITH_HEADROOM,
  87     KEEP_CURRENT = WebCacheManager::KEEP_CURRENT,
  88     KEEP_LIVE_WITH_HEADROOM = WebCacheManager::KEEP_LIVE_WITH_HEADROOM,
  89     KEEP_LIVE = WebCacheManager::KEEP_LIVE,
  90   };
  91
  92   WebCacheManager* manager() { return &manager_; }
  93
  94  private:
  95   WebCacheManager manager_;
  96   MessageLoop message_loop_;
  97   content::TestBrowserThread ui_thread_;
  98 };
  99
 100 // static
 101 const int WebCacheManagerTest::kRendererID = 146;
 102
 103 // static
 104 const int WebCacheManagerTest::kRendererID2 = 245;
 105
 106 // static
 107 const WebCache::UsageStats WebCacheManagerTest::kStats = {
 108     0,
 109     1024 * 1024,
 110     1024 * 1024,
 111     256 * 1024,
 112     512,
 113   };
 114
 115 // static
 116 const WebCache::UsageStats WebCacheManagerTest::kStats2 = {
 117     0,
 118     2 * 1024 * 1024,
 119     2 * 1024 * 1024,
 120     2 * 256 * 1024,
 121     2 * 512,
 122   };
 123
 124 static bool operator==(const WebCache::UsageStats& lhs,
 125                        const WebCache::UsageStats& rhs) {
 126   return !::memcmp(&lhs, &rhs, sizeof(WebCache::UsageStats));
 127 }
 128
 129 TEST_F(WebCacheManagerTest, AddRemoveRendererTest) {
 130   EXPECT_EQ(0U, active_renderers(manager()).size());
 131   EXPECT_EQ(0U, inactive_renderers(manager()).size());
 132
 133   manager()->Add(kRendererID);
 134   EXPECT_EQ(1U, active_renderers(manager()).count(kRendererID));
 135   EXPECT_EQ(0U, inactive_renderers(manager()).count(kRendererID));
 136
 137   manager()->Remove(kRendererID);
 138   EXPECT_EQ(0U, active_renderers(manager()).size());
 139   EXPECT_EQ(0U, inactive_renderers(manager()).size());
 140 }
 141
 142 TEST_F(WebCacheManagerTest, ActiveInactiveTest) {
 143   manager()->Add(kRendererID);
 144
 145   manager()->ObserveActivity(kRendererID);
 146   EXPECT_EQ(1U, active_renderers(manager()).count(kRendererID));
 147   EXPECT_EQ(0U, inactive_renderers(manager()).count(kRendererID));
 148
 149   SimulateInactivity(manager(), kRendererID);
 150   EXPECT_EQ(0U, active_renderers(manager()).count(kRendererID));
 151   EXPECT_EQ(1U, inactive_renderers(manager()).count(kRendererID));
 152
 153   manager()->ObserveActivity(kRendererID);
 154   EXPECT_EQ(1U, active_renderers(manager()).count(kRendererID));
 155   EXPECT_EQ(0U, inactive_renderers(manager()).count(kRendererID));
 156
 157   manager()->Remove(kRendererID);
 158 }
 159
 160 TEST_F(WebCacheManagerTest, ObserveStatsTest) {
 161   manager()->Add(kRendererID);
 162
 163   EXPECT_EQ(1U, stats(manager()).size());
 164
 165   manager()->ObserveStats(kRendererID, kStats);
 166
 167   EXPECT_EQ(1U, stats(manager()).size());
 168   EXPECT_TRUE(kStats == stats(manager())[kRendererID]);
 169
 170   manager()->Remove(kRendererID);
 171 }
 172
 173 TEST_F(WebCacheManagerTest, SetGlobalSizeLimitTest) {
 174   size_t limit = manager()->GetDefaultGlobalSizeLimit();
 175   manager()->SetGlobalSizeLimit(limit);
 176   EXPECT_EQ(limit, manager()->global_size_limit());
 177
 178   manager()->SetGlobalSizeLimit(0);
 179   EXPECT_EQ(0U, manager()->global_size_limit());
 180 }
 181
 182 TEST_F(WebCacheManagerTest, GatherStatsTest) {
 183   manager()->Add(kRendererID);
 184   manager()->Add(kRendererID2);
 185
 186   manager()->ObserveStats(kRendererID, kStats);
 187   manager()->ObserveStats(kRendererID2, kStats2);
 188
 189   std::set<int> renderer_set;
 190   renderer_set.insert(kRendererID);
 191
 192   WebCache::UsageStats stats;
 193   GatherStats(manager(), renderer_set, &stats);
 194
 195   EXPECT_TRUE(kStats == stats);
 196
 197   renderer_set.insert(kRendererID2);
 198   GatherStats(manager(), renderer_set, &stats);
 199
 200   WebCache::UsageStats expected_stats = kStats;
 201   expected_stats.minDeadCapacity += kStats2.minDeadCapacity;
 202   expected_stats.maxDeadCapacity += kStats2.maxDeadCapacity;
 203   expected_stats.capacity += kStats2.capacity;
 204   expected_stats.liveSize += kStats2.liveSize;
 205   expected_stats.deadSize += kStats2.deadSize;
 206
 207   EXPECT_TRUE(expected_stats == stats);
 208
 209   manager()->Remove(kRendererID);
 210   manager()->Remove(kRendererID2);
 211 }
 212
 213 TEST_F(WebCacheManagerTest, GetSizeTest) {
 214   EXPECT_EQ(0U, GetSize(DIVIDE_EVENLY, kStats));
 215   EXPECT_LT(256 * 1024u + 512, GetSize(KEEP_CURRENT_WITH_HEADROOM, kStats));
 216   EXPECT_EQ(256 * 1024u + 512, GetSize(KEEP_CURRENT, kStats));
 217   EXPECT_LT(256 * 1024u, GetSize(KEEP_LIVE_WITH_HEADROOM, kStats));
 218   EXPECT_EQ(256 * 1024u, GetSize(KEEP_LIVE, kStats));
 219 }
 220
 221 TEST_F(WebCacheManagerTest, AttemptTacticTest) {
 222   manager()->Add(kRendererID);
 223   manager()->Add(kRendererID2);
 224
 225   manager()->ObserveActivity(kRendererID);
 226   SimulateInactivity(manager(), kRendererID2);
 227
 228   manager()->ObserveStats(kRendererID, kStats);
 229   manager()->ObserveStats(kRendererID2, kStats2);
 230
 231   manager()->SetGlobalSizeLimit(kStats.liveSize + kStats.deadSize +
 232                         kStats2.liveSize + kStats2.deadSize/2);
 233
 234   AllocationStrategy strategy;
 235
 236   EXPECT_FALSE(AttemptTactic(manager(),
 237                              KEEP_CURRENT,
 238                              kStats,
 239                              KEEP_CURRENT,
 240                              kStats2,
 241                              &strategy));
 242   EXPECT_TRUE(strategy.empty());
 243
 244   EXPECT_TRUE(AttemptTactic(manager(),
 245                             KEEP_CURRENT,
 246                             kStats,
 247                             KEEP_LIVE,
 248                             kStats2,
 249                             &strategy));
 250   EXPECT_EQ(2U, strategy.size());
 251
 252   AllocationStrategy::iterator iter = strategy.begin();
 253   while (iter != strategy.end()) {
 254     if (iter->first == kRendererID)
 255       EXPECT_LE(kStats.liveSize + kStats.deadSize, iter->second);
 256     else if (iter->first == kRendererID2)
 257       EXPECT_LE(kStats2.liveSize, iter->second);
 258     else
 259       ADD_FAILURE();   // Unexpected entry in strategy.
 260     ++iter;
 261   }
 262
 263   manager()->Remove(kRendererID);
 264   manager()->Remove(kRendererID2);
 265 }
 266
 267 TEST_F(WebCacheManagerTest, AddToStrategyTest) {
 268   manager()->Add(kRendererID);
 269   manager()->Add(kRendererID2);
 270
 271   std::set<int> renderer_set;
 272   renderer_set.insert(kRendererID);
 273   renderer_set.insert(kRendererID2);
 274
 275   manager()->ObserveStats(kRendererID, kStats);
 276   manager()->ObserveStats(kRendererID2, kStats2);
 277
 278   const size_t kExtraBytesToAllocate = 10 * 1024;
 279
 280   AllocationStrategy strategy;
 281   AddToStrategy(manager(),
 282                 renderer_set,
 283                 KEEP_CURRENT,
 284                 kExtraBytesToAllocate,
 285                 &strategy);
 286
 287   EXPECT_EQ(2U, strategy.size());
 288
 289   size_t total_bytes = 0;
 290   AllocationStrategy::iterator iter = strategy.begin();
 291   while (iter != strategy.end()) {
 292     total_bytes += iter->second;
 293
 294     if (iter->first == kRendererID)
 295       EXPECT_LE(kStats.liveSize + kStats.deadSize, iter->second);
 296     else if (iter->first == kRendererID2)
 297       EXPECT_LE(kStats2.liveSize + kStats2.deadSize, iter->second);
 298     else
 299       ADD_FAILURE();  // Unexpected entry in strategy.
 300     ++iter;
 301   }
 302
 303   size_t expected_total_bytes = kExtraBytesToAllocate +
 304                                 kStats.liveSize + kStats.deadSize +
 305                                 kStats2.liveSize + kStats2.deadSize;
 306
 307   EXPECT_GE(expected_total_bytes, total_bytes);
 308
 309   manager()->Remove(kRendererID);
 310   manager()->Remove(kRendererID2);
 311 }