Fix quota handling in incognito mode.

When we're in incognito mode we should return a reasonably small
quota which allows webapps to store small values in their in-memory
temporary databases.

This is a fix for regression issue for our quota capping change
made in R26; currently we always return 0 quota if the profile is
in incognito mode.  Before the regression we used to return 50MB
quota for installed apps, which might have been too small. This
fixes the regression and increase the default quota limit for incognito
from 50MB to 100MB.

Regular case:
- Persistent quota is set to 0 (default)
- Temporary quota is always less than kIncognitoDefaultQuotaLimit

When unlimited permission is granted:
- Both (persistent and temporary) quota is set to kIncognitoDefaultQuotaLimit

BUG=234119
TEST=QuotaManagerTest.GetUsageAndQuota_Incognito
R=michaeln@chromium.org, tzik@chromium.org

Review URL: https://codereview.chromium.org/14602007

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

3 files changed, 75 insertions, 18 deletions

diff --git a/webkit/quota/quota_manager.cc b/webkit/quota/quota_manager.cc
index bd37634..0d9c5b9 100644
--- a/webkit/quota/quota_manager.cc
+++ b/webkit/quota/quota_manager.cc
@@ -40,7 +40,6 @@ namespace {
 const int64 kMBytes = 1024 * 1024;
 const int kMinutesInMilliSeconds = 60 * 1000;
 
-const int64 kIncognitoDefaultTemporaryQuota = 50 * kMBytes;
 const int64 kReportHistogramInterval = 60 * 60 * 1000;  // 1 hour
 const double kTemporaryQuotaRatioToAvail = 0.5;  // 50%
 
@@ -162,6 +161,11 @@ int64 CallSystemGetAmountOfFreeDiskSpace(const base::FilePath& profile_path) {
 
 }  // anonymous namespace
 
+// Arbitrary for now, but must be reasonably small so that
+// in-memory databases can fit.
+// TODO(kinuko): Refer SysInfo::AmountOfPhysicalMemory() to determine this.
+const int64 QuotaManager::kIncognitoDefaultQuotaLimit = 100 * kMBytes;
+
 const int64 QuotaManager::kNoLimit = kint64max;
 
 const int QuotaManager::kPerHostTemporaryPortion = 5;  // 20%
@@ -203,10 +207,22 @@ int64 CalculateQuotaWithDiskSpace(
 // Callback translators.
 void CallGetUsageAndQuotaCallback(
     const QuotaManager::GetUsageAndQuotaCallback& callback,
+    bool is_incognito,
     bool unlimited,
     bool can_query_disk_size,
     QuotaStatusCode status,
     const QuotaAndUsage& quota_and_usage) {
+  // Incognito case.  Cap the quota by kIncognitoDefaultQuotaLimit, but
+  // no need to refer the actual disk size (because data will be stored
+  // in-memory in incognito mode).
+  if (is_incognito) {
+    int64 quota = unlimited ? QuotaManager::kNoLimit : quota_and_usage.quota;
+    callback.Run(status,
+                 quota_and_usage.usage,
+                 std::min(quota, QuotaManager::kIncognitoDefaultQuotaLimit));
+    return;
+  }
+
   // Regular limited case.
   if (!unlimited) {
     if (can_query_disk_size) {
@@ -222,12 +238,11 @@ void CallGetUsageAndQuotaCallback(
     return;
   }
 
-  int64 usage = quota_and_usage.unlimited_usage;
-
   // Unlimited case: this must be only for apps with unlimitedStorage permission
   // or only when --unlimited-storage flag is given.
   // We assume we can expose the disk size for them and return the available
   // disk space (minus kMinimumPreserveForSystem).
+  int64 usage = quota_and_usage.unlimited_usage;
   callback.Run(status, usage,
                CalculateQuotaWithDiskSpace(
                    quota_and_usage.available_disk_space,
@@ -968,7 +983,9 @@ void QuotaManager::GetUsageAndQuotaForWebApps(
   GetUsageAndQuotaInternal(
       origin, type, false /* global */,
       base::Bind(&CallGetUsageAndQuotaCallback, callback,
-                 IsStorageUnlimited(origin, type), CanQueryDiskSize(origin)));
+                 is_incognito_,
+                 IsStorageUnlimited(origin, type),
+                 CanQueryDiskSize(origin)));
 }
 
 void QuotaManager::GetUsageAndQuota(
@@ -978,7 +995,8 @@ void QuotaManager::GetUsageAndQuota(
 
   if (IsStorageUnlimited(origin, type)) {
     CallGetUsageAndQuotaCallback(
-        callback, false, CanQueryDiskSize(origin),
+        callback, is_incognito_,
+        false /* unlimited */, CanQueryDiskSize(origin),
         kQuotaStatusOk, QuotaAndUsage::CreateForUnlimitedStorage());
     return;
   }
@@ -1054,11 +1072,6 @@ void QuotaManager::DeleteHostData(const std::string& host,
 }
 
 void QuotaManager::GetAvailableSpace(const AvailableSpaceCallback& callback) {
-  if (is_incognito_) {
-    callback.Run(kQuotaStatusOk, kIncognitoDefaultTemporaryQuota);
-    return;
-  }
-
   PostTaskAndReplyWithResult(
       db_thread_,
       FROM_HERE,
diff --git a/webkit/quota/quota_manager.h b/webkit/quota/quota_manager.h
index 6a435ca..af6f69d 100644
--- a/webkit/quota/quota_manager.h
+++ b/webkit/quota/quota_manager.h
@@ -109,6 +109,8 @@ class WEBKIT_STORAGE_EXPORT QuotaManager
                               int64 /* usage */,
                               int64 /* quota */)>
       GetUsageAndQuotaCallback;
+
+  static const int64 kIncognitoDefaultQuotaLimit;
   static const int64 kNoLimit;
 
   QuotaManager(bool is_incognito,
diff --git a/webkit/quota/quota_manager_unittest.cc b/webkit/quota/quota_manager_unittest.cc
index b670af3..c60be73 100644
--- a/webkit/quota/quota_manager_unittest.cc
+++ b/webkit/quota/quota_manager_unittest.cc
@@ -63,8 +63,19 @@ class QuotaManagerTest : public testing::Test {
   virtual void SetUp() {
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
     mock_special_storage_policy_ = new MockSpecialStoragePolicy;
+    ResetQuotaManager(false /* is_incognito */);
+  }
+
+  virtual void TearDown() {
+    // Make sure the quota manager cleans up correctly.
+    quota_manager_ = NULL;
+    MessageLoop::current()->RunUntilIdle();
+  }
+
+ protected:
+  void ResetQuotaManager(bool is_incognito) {
     quota_manager_ = new QuotaManager(
-        false /* is_incognito */,
+        is_incognito,
         data_dir_.path(),
         MessageLoopProxy::current(),
         MessageLoopProxy::current(),
@@ -76,13 +87,6 @@ class QuotaManagerTest : public testing::Test {
     additional_callback_count_ = 0;
   }
 
-  virtual void TearDown() {
-    // Make sure the quota manager cleans up correctly.
-    quota_manager_ = NULL;
-    MessageLoop::current()->RunUntilIdle();
-  }
-
- protected:
   MockStorageClient* CreateClient(
       const MockOriginData* mock_data,
       size_t mock_data_size,
@@ -2139,4 +2143,42 @@ TEST_F(QuotaManagerTest, DeleteMultipleClientTypesSingleHost) {
   EXPECT_EQ(predelete_foo_tmp - 8 - 4 - 2 - 1, usage());
 }
 
+TEST_F(QuotaManagerTest, GetUsageAndQuota_Incognito) {
+  ResetQuotaManager(true);
+
+  static const MockOriginData kData[] = {
+    { "http://foo.com/", kTemp, 10 },
+    { "http://foo.com/", kPerm, 80 },
+  };
+  RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+      QuotaClient::kFileSystem));
+
+  GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kPerm);
+  MessageLoop::current()->RunUntilIdle();
+  EXPECT_EQ(kQuotaStatusOk, status());
+  EXPECT_EQ(80, usage());
+  EXPECT_EQ(0, quota());
+
+  SetTemporaryGlobalQuota(100);
+  GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
+  MessageLoop::current()->RunUntilIdle();
+  EXPECT_EQ(kQuotaStatusOk, status());
+  EXPECT_EQ(10, usage());
+  EXPECT_LE(std::min(static_cast<int64>(100 / kPerHostTemporaryPortion),
+                     QuotaManager::kIncognitoDefaultQuotaLimit), quota());
+
+  mock_special_storage_policy()->AddUnlimited(GURL("http://foo.com/"));
+  GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kPerm);
+  MessageLoop::current()->RunUntilIdle();
+  EXPECT_EQ(kQuotaStatusOk, status());
+  EXPECT_EQ(80, usage());
+  EXPECT_EQ(QuotaManager::kIncognitoDefaultQuotaLimit, quota());
+
+  GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
+  MessageLoop::current()->RunUntilIdle();
+  EXPECT_EQ(kQuotaStatusOk, status());
+  EXPECT_EQ(10, usage());
+  EXPECT_EQ(QuotaManager::kIncognitoDefaultQuotaLimit, quota());
+}
+
 }  // namespace quota