Make PreferredCacheSize(avail) <= avail*0.8 and f(x) <= f(x+1).

Contributed by slamm@google.com 

BUG=40079
TEST=DiskCacheTest.AutomaticMaxSize

http://codereview.chromium.org/1564007

Review URL: http://codereview.chromium.org/1566021

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@43749 0039d316-1c4b-4281-b951-d872f2087c98

2 files changed, 60 insertions, 38 deletions

diff --git a/net/disk_cache/backend_impl.cc b/net/disk_cache/backend_impl.cc
index 534c33f..98b8804a 100644
--- a/net/disk_cache/backend_impl.cc
+++ b/net/disk_cache/backend_impl.cc
@@ -183,30 +183,33 @@ int CreateCacheBackend(net::CacheType type, const FilePath& path, int max_bytes,
   return *backend ? net::OK : net::ERR_FAILED;
 }
 
+// Returns the preferred maximum number of bytes for the cache given the
+// number of available bytes.
 int PreferedCacheSize(int64 available) {
-  // If there is not enough space to use kDefaultCacheSize, use 80% of the
-  // available space.
-  if (available < kDefaultCacheSize)
+  // Return 80% of the available space if there is not enough space to use
+  // kDefaultCacheSize.
+  if (available < kDefaultCacheSize * 10 / 8)
     return static_cast<int32>(available * 8 / 10);
 
-  // Don't use more than 10% of the available space.
-  if (available < 10 * kDefaultCacheSize)
+  // Return kDefaultCacheSize if it uses 80% to 10% of the available space.
+  if (available < kDefaultCacheSize * 10)
     return kDefaultCacheSize;
 
-  // Use 10% of the free space until we reach 2.5 * kDefaultCacheSize.
+  // Return 10% of the available space if the target size
+  // (2.5 * kDefaultCacheSize) is more than 10%.
   if (available < static_cast<int64>(kDefaultCacheSize) * 25)
     return static_cast<int32>(available / 10);
 
-  // After reaching our target size (2.5 * kDefaultCacheSize), attempt to use
-  // 1% of the availabe space.
-  if (available < static_cast<int64>(kDefaultCacheSize) * 100)
+  // Return the target size (2.5 * kDefaultCacheSize) if it uses 10% to 1%
+  // of the available space.
+  if (available < static_cast<int64>(kDefaultCacheSize) * 250)
     return kDefaultCacheSize * 5 / 2;
 
-  int64 one_percent = available / 100;
-  if (one_percent > kint32max)
-    return kint32max;
+  // Return 1% of the available space if it does not exceed kint32max.
+  if (available < static_cast<int64>(kint32max) * 100)
+    return static_cast<int32>(available / 100);
 
-  return static_cast<int32>(one_percent);
+  return kint32max;
 }
 
 // ------------------------------------------------------------------------
diff --git a/net/disk_cache/backend_unittest.cc b/net/disk_cache/backend_unittest.cc
index bd1bca1..abc2c08 100644
--- a/net/disk_cache/backend_unittest.cc
+++ b/net/disk_cache/backend_unittest.cc
@@ -1559,32 +1559,51 @@ TEST_F(DiskCacheTest, MultipleInstances) {
   }
 }
 
-// Test the four regions of the curve that determines the max cache size.
+// Test the six regions of the curve that determines the max cache size.
 TEST_F(DiskCacheTest, AutomaticMaxSize) {
   const int kDefaultSize = 80 * 1024 * 1024;
   int64 large_size = kDefaultSize;
-
-  EXPECT_EQ(kDefaultSize, disk_cache::PreferedCacheSize(large_size));
-  EXPECT_EQ((kDefaultSize / 2) * 8 / 10,
-            disk_cache::PreferedCacheSize(large_size / 2));
-
-  EXPECT_EQ(kDefaultSize, disk_cache::PreferedCacheSize(large_size * 2));
-  EXPECT_EQ(kDefaultSize, disk_cache::PreferedCacheSize(large_size * 4));
-  EXPECT_EQ(kDefaultSize, disk_cache::PreferedCacheSize(large_size * 10));
-
-  EXPECT_EQ(kDefaultSize * 2, disk_cache::PreferedCacheSize(large_size * 20));
-  EXPECT_EQ(kDefaultSize * 5 / 2,
-            disk_cache::PreferedCacheSize(large_size * 50 / 2));
-
-  EXPECT_EQ(kDefaultSize * 5 / 2,
-            disk_cache::PreferedCacheSize(large_size * 51 / 2));
-  EXPECT_EQ(kDefaultSize * 5 / 2,
-            disk_cache::PreferedCacheSize(large_size * 100 / 2));
-  EXPECT_EQ(kDefaultSize * 5 / 2,
-            disk_cache::PreferedCacheSize(large_size * 500 / 2));
-
-  EXPECT_EQ(kDefaultSize * 6 / 2,
-            disk_cache::PreferedCacheSize(large_size * 600 / 2));
-  EXPECT_EQ(kDefaultSize * 7 / 2,
-            disk_cache::PreferedCacheSize(large_size * 700 / 2));
+  int64 largest_size = kint32max;
+
+  // Region 1: expected = available * 0.8
+  EXPECT_EQ((kDefaultSize - 1) * 8 / 10,
+            disk_cache::PreferedCacheSize(large_size - 1));
+  EXPECT_EQ(kDefaultSize * 8 / 10,
+            disk_cache::PreferedCacheSize(large_size));
+  EXPECT_EQ(kDefaultSize - 1,
+            disk_cache::PreferedCacheSize(large_size * 10 / 8 - 1));
+
+  // Region 2: expected = default_size
+  EXPECT_EQ(kDefaultSize,
+            disk_cache::PreferedCacheSize(large_size * 10 / 8));
+  EXPECT_EQ(kDefaultSize,
+            disk_cache::PreferedCacheSize(large_size * 10 - 1));
+
+  // Region 3: expected = available * 0.1
+  EXPECT_EQ(kDefaultSize,
+            disk_cache::PreferedCacheSize(large_size * 10));
+  EXPECT_EQ((kDefaultSize * 25 - 1) / 10,
+            disk_cache::PreferedCacheSize(large_size * 25 - 1));
+
+  // Region 4: expected = default_size * 2.5
+  EXPECT_EQ(kDefaultSize * 25 / 10,
+            disk_cache::PreferedCacheSize(large_size * 25));
+  EXPECT_EQ(kDefaultSize * 25 / 10,
+            disk_cache::PreferedCacheSize(large_size * 100 - 1));
+  EXPECT_EQ(kDefaultSize * 25 / 10,
+            disk_cache::PreferedCacheSize(large_size * 100));
+  EXPECT_EQ(kDefaultSize * 25 / 10,
+            disk_cache::PreferedCacheSize(large_size * 250 - 1));
+
+  // Region 5: expected = available * 0.1
+  EXPECT_EQ(kDefaultSize * 25 / 10,
+            disk_cache::PreferedCacheSize(large_size * 250));
+  EXPECT_EQ(kint32max - 1,
+            disk_cache::PreferedCacheSize(largest_size * 100 - 1));
+
+  // Region 6: expected = kint32max
+  EXPECT_EQ(kint32max,
+            disk_cache::PreferedCacheSize(largest_size * 100));
+  EXPECT_EQ(kint32max,
+            disk_cache::PreferedCacheSize(largest_size * 10000));
 }