Remove `kMockStart` from `quota::MockStorageClient`

webkit/quota/quota_manager_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <set>
 #include <sstream>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/file_util.h"
@@ skipping 49 matching lines @@
   }
 
   void TearDown() {
     // Make sure the quota manager cleans up correctly.
     quota_manager_ = NULL;
     MessageLoop::current()->RunAllPending();
   }
 
  protected:
   MockStorageClient* CreateClient(
-      const MockOriginData* mock_data, size_t mock_data_size) {
-    return new MockStorageClient(quota_manager_->proxy(),
-                                 mock_data, mock_data_size);
-  }
-  MockStorageClient* CreateClient(
       const MockOriginData* mock_data,
       size_t mock_data_size,
       QuotaClient::ID id) {
     return new MockStorageClient(quota_manager_->proxy(),
                                  mock_data, id, mock_data_size);
   }
 
   void RegisterClient(MockStorageClient* client) {
     quota_manager_->proxy()->RegisterClient(client);
   }
@@ skipping 353 matching lines @@
     { "http://foo.com:8080/",  kTemp,  15 },
     { "http://bar.com/",       kTemp,  20 },
     { "http://bar.com/",       kPerm,  50 },
   };
   static const MockOriginData kData2[] = {
     { "https://foo.com/",      kTemp,  30 },
     { "https://foo.com:8081/", kTemp,  35 },
     { "http://bar.com/",       kPerm,  40 },
     { "http://example.com/",   kPerm,  40 },
   };
-  RegisterClient(CreateClient(kData1, ARRAYSIZE_UNSAFE(kData1)));
-  RegisterClient(CreateClient(kData2, ARRAYSIZE_UNSAFE(kData2)));
+  RegisterClient(CreateClient(kData1, ARRAYSIZE_UNSAFE(kData1),
+      QuotaClient::kFileSystem));
+  RegisterClient(CreateClient(kData2, ARRAYSIZE_UNSAFE(kData2),
+      QuotaClient::kDatabase));
 
   GetUsageInfo();
   MessageLoop::current()->RunAllPending();
 
   EXPECT_EQ(4U, usage_info().size());
   for (size_t i = 0; i < usage_info().size(); ++i) {
     const UsageInfo& info = usage_info()[i];
     if (info.host == "foo.com" && info.type == kTemp) {
       EXPECT_EQ(10 + 15 + 30 + 35, info.usage);
     } else if (info.host == "bar.com" && info.type == kTemp) {
       EXPECT_EQ(20, info.usage);
     } else if (info.host == "bar.com" && info.type == kPerm) {
       EXPECT_EQ(50 + 40, info.usage);
     } else if (info.host == "example.com" && info.type == kPerm) {
       EXPECT_EQ(40, info.usage);
     } else {
       ADD_FAILURE()
           << "Unexpected host, type: " << info.host << ", " << info.type;
     }
   }
 }
 
 TEST_F(QuotaManagerTest, GetUsageAndQuota_Simple) {
   static const MockOriginData kData[] = {
     { "http://foo.com/", kTemp, 10 },
     { "http://foo.com/", kPerm, 80 },
   };
-  RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData)));
+  RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+      QuotaClient::kFileSystem));
 
   GetUsageAndQuota(GURL("http://foo.com/"), kPerm);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(80, usage());
   EXPECT_EQ(0, quota());
 
   GetUsageAndQuota(GURL("http://foo.com/"), kTemp);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
@@ skipping 32 matching lines @@
   EXPECT_EQ(0, usage());
   EXPECT_EQ(0, unlimited_usage());
 
   GetGlobalUsage(kPerm);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(0, usage());
   EXPECT_EQ(0, unlimited_usage());
 }
 
 TEST_F(QuotaManagerTest, GetUsage_EmptyClient) {
-  RegisterClient(CreateClient(NULL, 0));
+  RegisterClient(CreateClient(NULL, 0, QuotaClient::kFileSystem));
   GetUsageAndQuota(GURL("http://foo.com/"), kTemp);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(0, usage());
 
   GetUsageAndQuota(GURL("http://foo.com/"), kPerm);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(0, usage());
 
@@ skipping 18 matching lines @@
 
 TEST_F(QuotaManagerTest, GetTemporaryUsageAndQuota_MultiOrigins) {
   static const MockOriginData kData[] = {
     { "http://foo.com/",        kTemp,  10 },
     { "http://foo.com:8080/",   kTemp,  20 },
     { "http://bar.com/",        kTemp,   5 },
     { "https://bar.com/",       kTemp,   7 },
     { "http://baz.com/",        kTemp,  30 },
     { "http://foo.com/",        kPerm,  40 },
   };
-  RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData)));
+  RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+      QuotaClient::kFileSystem));
 
   // This time explicitly sets a temporary global quota.
   SetTemporaryGlobalQuota(100);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kTemp, type());
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(100, quota());
 
   GetUsageAndQuota(GURL("http://foo.com/"), kTemp);
   MessageLoop::current()->RunAllPending();
@@ skipping 19 matching lines @@
     { "http://bar.com/",     kTemp,  20 },
     { "http://bar.com/",     kPerm, 50 },
     { "http://unlimited/",   kPerm,  1 },
   };
   static const MockOriginData kData2[] = {
     { "https://foo.com/",    kTemp,  30 },
     { "http://example.com/", kPerm, 40 },
     { "http://unlimited/",   kTemp,   1 },
   };
   mock_special_storage_policy()->AddUnlimited(GURL("http://unlimited/"));
-  RegisterClient(CreateClient(kData1, ARRAYSIZE_UNSAFE(kData1)));
-  RegisterClient(CreateClient(kData2, ARRAYSIZE_UNSAFE(kData2)));
+  RegisterClient(CreateClient(kData1, ARRAYSIZE_UNSAFE(kData1),
+      QuotaClient::kFileSystem));
+  RegisterClient(CreateClient(kData2, ARRAYSIZE_UNSAFE(kData2),
+      QuotaClient::kDatabase));
 
   GetUsageAndQuota(GURL("http://foo.com/"), kTemp);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(10 + 30, usage());
 
   GetUsageAndQuota(GURL("http://bar.com/"), kPerm);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(50, usage());
@@ skipping 21 matching lines @@
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(40 + 50 + 1, usage());
   EXPECT_EQ(1, unlimited_usage());
 }
 
 void QuotaManagerTest::GetUsage_WithModifyTestBody(const StorageType type) {
   const MockOriginData data[] = {
     { "http://foo.com/",   type,  10 },
     { "http://foo.com:1/", type,  20 },
   };
-  MockStorageClient* client = CreateClient(data, ARRAYSIZE_UNSAFE(data));
+  MockStorageClient* client = CreateClient(data, ARRAYSIZE_UNSAFE(data),
+      QuotaClient::kFileSystem);
   RegisterClient(client);
 
   GetUsageAndQuota(GURL("http://foo.com/"), type);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(10 + 20, usage());
 
   client->ModifyOriginAndNotify(GURL("http://foo.com/"), type, 30);
   client->ModifyOriginAndNotify(GURL("http://foo.com:1/"), type, -5);
   client->AddOriginAndNotify(GURL("https://foo.com/"), type, 1);
@@ skipping 20 matching lines @@
   GetUsage_WithModifyTestBody(kTemp);
 }
 
 TEST_F(QuotaManagerTest, GetTemporaryUsageAndQuota_WithAdditionalTasks) {
   static const MockOriginData kData[] = {
     { "http://foo.com/",        kTemp, 10 },
     { "http://foo.com:8080/",   kTemp, 20 },
     { "http://bar.com/",        kTemp, 13 },
     { "http://foo.com/",        kPerm, 40 },
   };
-  RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData)));
+  RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+      QuotaClient::kFileSystem));
   SetTemporaryGlobalQuota(100);
   MessageLoop::current()->RunAllPending();
 
   const int kPerHostQuota = 100 / QuotaManager::kPerHostTemporaryPortion;
 
   GetUsageAndQuota(GURL("http://foo.com/"), kTemp);
   GetUsageAndQuota(GURL("http://foo.com/"), kTemp);
   GetUsageAndQuota(GURL("http://foo.com/"), kTemp);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
@@ skipping 13 matching lines @@
   EXPECT_EQ(2, additional_callback_count());
 }
 
 TEST_F(QuotaManagerTest, GetTemporaryUsageAndQuota_NukeManager) {
   static const MockOriginData kData[] = {
     { "http://foo.com/",        kTemp, 10 },
     { "http://foo.com:8080/",   kTemp, 20 },
     { "http://bar.com/",        kTemp, 13 },
     { "http://foo.com/",        kPerm, 40 },
   };
-  RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData)));
+  RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+      QuotaClient::kFileSystem));
   SetTemporaryGlobalQuota(100);
   MessageLoop::current()->RunAllPending();
 
   set_additional_callback_count(0);
   GetUsageAndQuota(GURL("http://foo.com/"), kTemp);
   RunAdditionalUsageAndQuotaTask(GURL("http://foo.com/"),
                                  kTemp);
   RunAdditionalUsageAndQuotaTask(GURL("http://bar.com/"),
                                  kTemp);
 
   DeleteOriginData(GURL("http://foo.com/"), kTemp, kAllClients);
   DeleteOriginData(GURL("http://bar.com/"), kTemp, kAllClients);
 
   // Nuke before waiting for callbacks.
   set_quota_manager(NULL);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaErrorAbort, status());
 }
 
 TEST_F(QuotaManagerTest, GetTemporaryUsageAndQuota_Overbudget) {
   static const MockOriginData kData[] = {
     { "http://usage1/",    kTemp,   1 },
     { "http://usage10/",   kTemp,  10 },
     { "http://usage200/",  kTemp, 200 },
   };
-  RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData)));
+  RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+      QuotaClient::kFileSystem));
   SetTemporaryGlobalQuota(100);
   MessageLoop::current()->RunAllPending();
 
   const int kPerHostQuota = 100 / QuotaManager::kPerHostTemporaryPortion;
 
   GetUsageAndQuota(GURL("http://usage1/"), kTemp);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(1, usage());
   EXPECT_EQ(1, quota());  // should be clamped to our current usage
@@ skipping 11 matching lines @@
   EXPECT_EQ(kPerHostQuota, quota());  // should be clamped to the nominal quota
 }
 
 TEST_F(QuotaManagerTest, GetTemporaryUsageAndQuota_Unlimited) {
   static const MockOriginData kData[] = {
     { "http://usage10/",   kTemp,    10 },
     { "http://usage50/",   kTemp,    50 },
     { "http://unlimited/", kTemp,  4000 },
   };
   mock_special_storage_policy()->AddUnlimited(GURL("http://unlimited/"));
-  MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData));
+  MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+      QuotaClient::kFileSystem);
   RegisterClient(client);
 
   // Test when not overbugdet.
   SetTemporaryGlobalQuota(1000);
   MessageLoop::current()->RunAllPending();
 
   GetGlobalUsage(kTemp);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(10 + 50 + 4000, usage());
   EXPECT_EQ(4000, unlimited_usage());
@@ skipping 88 matching lines @@
   quota_manager()->NotifyOriginInUse(kBarOrigin);
   EXPECT_TRUE(quota_manager()->IsOriginInUse(kBarOrigin));
   quota_manager()->NotifyOriginNoLongerInUse(kBarOrigin);
   EXPECT_FALSE(quota_manager()->IsOriginInUse(kBarOrigin));
 
   quota_manager()->NotifyOriginNoLongerInUse(kFooOrigin);
   EXPECT_FALSE(quota_manager()->IsOriginInUse(kFooOrigin));
 }
 
 TEST_F(QuotaManagerTest, GetAndSetPerststentHostQuota) {
-  RegisterClient(CreateClient(NULL, 0));
+  RegisterClient(CreateClient(NULL, 0, QuotaClient::kFileSystem));
 
   GetPersistentHostQuota("foo.com");
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ("foo.com", host());
   EXPECT_EQ(kPerm, type());
   EXPECT_EQ(0, quota());
 
   SetPersistentHostQuota("foo.com", 100);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(100, quota());
 
   GetPersistentHostQuota("foo.com");
   SetPersistentHostQuota("foo.com", 200);
   GetPersistentHostQuota("foo.com");
   SetPersistentHostQuota("foo.com", 300000000000ll);
   GetPersistentHostQuota("foo.com");
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(300000000000ll, quota());
 }
 
 TEST_F(QuotaManagerTest, GetAndSetPersistentUsageAndQuota) {
-  RegisterClient(CreateClient(NULL, 0));
+  RegisterClient(CreateClient(NULL, 0, QuotaClient::kFileSystem));
 
   GetUsageAndQuota(GURL("http://foo.com/"), kPerm);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(0, usage());
   EXPECT_EQ(0, quota());
 
   SetPersistentHostQuota("foo.com", 100);
   GetUsageAndQuota(GURL("http://foo.com/"), kPerm);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(0, usage());
   EXPECT_EQ(100, quota());
 }
 
 TEST_F(QuotaManagerTest, GetPersistentUsageAndQuota_MultiOrigins) {
   static const MockOriginData kData[] = {
     { "http://foo.com/",        kPerm, 10 },
     { "http://foo.com:8080/",   kPerm, 20 },
     { "https://foo.com/",       kPerm, 13 },
     { "https://foo.com:8081/",  kPerm, 19 },
     { "http://bar.com/",        kPerm,  5 },
     { "https://bar.com/",       kPerm,  7 },
     { "http://baz.com/",        kPerm, 30 },
     { "http://foo.com/",        kTemp, 40 },
   };
-  RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData)));
+  RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+      QuotaClient::kFileSystem));
 
   SetPersistentHostQuota("foo.com", 100);
   GetUsageAndQuota(GURL("http://foo.com/"), kPerm);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(10 + 20 + 13 + 19, usage());
   EXPECT_EQ(100, quota());
 }
 
 TEST_F(QuotaManagerTest, GetPersistentUsage_WithModify) {
   GetUsage_WithModifyTestBody(kPerm);
 }
 
 TEST_F(QuotaManagerTest, GetPersistentUsageAndQuota_WithAdditionalTasks) {
   static const MockOriginData kData[] = {
     { "http://foo.com/",        kPerm,  10 },
     { "http://foo.com:8080/",   kPerm,  20 },
     { "http://bar.com/",        kPerm,  13 },
     { "http://foo.com/",        kTemp,  40 },
   };
-  RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData)));
+  RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+      QuotaClient::kFileSystem));
   SetPersistentHostQuota("foo.com", 100);
 
   GetUsageAndQuota(GURL("http://foo.com/"), kPerm);
   GetUsageAndQuota(GURL("http://foo.com/"), kPerm);
   GetUsageAndQuota(GURL("http://foo.com/"), kPerm);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(10 + 20, usage());
   EXPECT_EQ(100, quota());
 
   set_additional_callback_count(0);
   RunAdditionalUsageAndQuotaTask(GURL("http://foo.com/"),
                                  kPerm);
   GetUsageAndQuota(GURL("http://foo.com/"), kPerm);
   RunAdditionalUsageAndQuotaTask(GURL("http://bar.com/"),
                                  kPerm);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(10 + 20, usage());
   EXPECT_EQ(2, additional_callback_count());
 }
 
 TEST_F(QuotaManagerTest, GetPersistentUsageAndQuota_NukeManager) {
   static const MockOriginData kData[] = {
     { "http://foo.com/",        kPerm,  10 },
     { "http://foo.com:8080/",   kPerm,  20 },
     { "http://bar.com/",        kPerm,  13 },
     { "http://foo.com/",        kTemp,  40 },
   };
-  RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData)));
+  RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+      QuotaClient::kFileSystem));
   SetPersistentHostQuota("foo.com", 100);
 
   set_additional_callback_count(0);
   GetUsageAndQuota(GURL("http://foo.com/"), kPerm);
   RunAdditionalUsageAndQuotaTask(GURL("http://foo.com/"),
                                  kPerm);
   RunAdditionalUsageAndQuotaTask(GURL("http://bar.com/"),
                                  kPerm);
 
   // Nuke before waiting for callbacks.
   set_quota_manager(NULL);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaErrorAbort, status());
 }
 
 TEST_F(QuotaManagerTest, GetUsage_Simple) {
   static const MockOriginData kData[] = {
     { "http://foo.com/",   kPerm,       1 },
     { "http://foo.com:1/", kPerm,      20 },
     { "http://bar.com/",   kTemp,     300 },
     { "https://buz.com/",  kTemp,    4000 },
     { "http://buz.com/",   kTemp,   50000 },
     { "http://bar.com:1/", kPerm,  600000 },
     { "http://foo.com/",   kTemp, 7000000 },
   };
-  RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData)));
+  RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+      QuotaClient::kFileSystem));
 
   GetGlobalUsage(kPerm);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(usage(), 1 + 20 + 600000);
   EXPECT_EQ(0, unlimited_usage());
 
   GetGlobalUsage(kTemp);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(usage(), 300 + 4000 + 50000 + 7000000);
   EXPECT_EQ(0, unlimited_usage());
@@ skipping 11 matching lines @@
   static const MockOriginData kData[] = {
     { "http://foo.com/",   kPerm,       1 },
     { "http://foo.com:1/", kPerm,      20 },
     { "http://bar.com/",   kTemp,     300 },
     { "https://buz.com/",  kTemp,    4000 },
     { "http://buz.com/",   kTemp,   50000 },
     { "http://bar.com:1/", kPerm,  600000 },
     { "http://foo.com/",   kTemp, 7000000 },
   };
 
-  MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData));
+  MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+      QuotaClient::kFileSystem);
   RegisterClient(client);
 
   GetGlobalUsage(kPerm);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(usage(), 1 + 20 + 600000);
   EXPECT_EQ(0, unlimited_usage());
 
   client->ModifyOriginAndNotify(
       GURL("http://foo.com/"), kPerm, 80000000);
 
@@ skipping 27 matching lines @@
   EXPECT_EQ(usage(), 4000 + 50000 + 900000000);
 }
 
 TEST_F(QuotaManagerTest, GetUsage_WithDeleteOrigin) {
   static const MockOriginData kData[] = {
     { "http://foo.com/",   kTemp,     1 },
     { "http://foo.com:1/", kTemp,    20 },
     { "http://foo.com/",   kPerm,   300 },
     { "http://bar.com/",   kTemp,  4000 },
   };
-  MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData));
+  MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+      QuotaClient::kFileSystem);
   RegisterClient(client);
 
   GetGlobalUsage(kTemp);
   MessageLoop::current()->RunAllPending();
   int64 predelete_global_tmp = usage();
 
   GetHostUsage("foo.com", kTemp);
   MessageLoop::current()->RunAllPending();
   int64 predelete_host_tmp = usage();
 
@@ skipping 33 matching lines @@
     { "http://foo.com/",   kPerm,   300 },
     { "http://bar.com/",   kTemp,  4000 },
   };
   static const MockOriginData kData2[] = {
     { "http://foo.com/",   kTemp, 50000 },
     { "http://foo.com:1/", kTemp,  6000 },
     { "http://foo.com/",   kPerm,   700 },
     { "https://foo.com/",  kTemp,    80 },
     { "http://bar.com/",   kTemp,     9 },
   };
-  MockStorageClient* client1 = CreateClient(kData1, ARRAYSIZE_UNSAFE(kData1));
-  MockStorageClient* client2 = CreateClient(kData2, ARRAYSIZE_UNSAFE(kData2));
+  MockStorageClient* client1 = CreateClient(kData1, ARRAYSIZE_UNSAFE(kData1),
+      QuotaClient::kFileSystem);
+  MockStorageClient* client2 = CreateClient(kData2, ARRAYSIZE_UNSAFE(kData2),
+      QuotaClient::kDatabase);
   RegisterClient(client1);
   RegisterClient(client2);
 
   GetGlobalUsage(kTemp);
   MessageLoop::current()->RunAllPending();
   int64 predelete_global_tmp = usage();
 
   GetHostUsage("foo.com", kTemp);
   MessageLoop::current()->RunAllPending();
   int64 predelete_host_tmp = usage();
 
   GetHostUsage("foo.com", kPerm);
   MessageLoop::current()->RunAllPending();
   int64 predelete_host_pers = usage();
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kData1); ++i)
-    quota_manager()->NotifyStorageAccessed(QuotaClient::kMockStart,
+    quota_manager()->NotifyStorageAccessed(QuotaClient::kUnknown,
         GURL(kData1[i].origin), kData1[i].type);
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kData2); ++i)
-    quota_manager()->NotifyStorageAccessed(QuotaClient::kMockStart,
+    quota_manager()->NotifyStorageAccessed(QuotaClient::kUnknown,
         GURL(kData2[i].origin), kData2[i].type);
   MessageLoop::current()->RunAllPending();
 
   EvictOriginData(GURL("http://foo.com/"), kTemp);
   MessageLoop::current()->RunAllPending();
 
   DumpOriginInfoTable();
   MessageLoop::current()->RunAllPending();
 
   typedef OriginInfoTableEntries::const_iterator iterator;
@@ skipping 18 matching lines @@
 }
 
 TEST_F(QuotaManagerTest, EvictOriginDataWithDeletionError) {
   static const MockOriginData kData[] = {
     { "http://foo.com/",   kTemp,       1 },
     { "http://foo.com:1/", kTemp,      20 },
     { "http://foo.com/",   kPerm,     300 },
     { "http://bar.com/",   kTemp,    4000 },
   };
   static const int kNumberOfTemporaryOrigins = 3;
-  MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData));
+  MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+      QuotaClient::kFileSystem);
   RegisterClient(client);
 
   GetGlobalUsage(kTemp);
   MessageLoop::current()->RunAllPending();
   int64 predelete_global_tmp = usage();
 
   GetHostUsage("foo.com", kTemp);
   MessageLoop::current()->RunAllPending();
   int64 predelete_host_tmp = usage();
 
@@ skipping 64 matching lines @@
 
 TEST_F(QuotaManagerTest, GetUsageAndQuotaForEviction) {
   static const MockOriginData kData[] = {
     { "http://foo.com/",   kTemp,       1 },
     { "http://foo.com:1/", kTemp,      20 },
     { "http://foo.com/",   kPerm,     300 },
     { "http://unlimited/", kTemp,    4000 },
   };
 
   mock_special_storage_policy()->AddUnlimited(GURL("http://unlimited/"));
-  MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData));
+  MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+      QuotaClient::kFileSystem);
   RegisterClient(client);
 
   SetTemporaryGlobalQuota(10000000);
   MessageLoop::current()->RunAllPending();
 
   GetUsageAndQuotaForEviction();
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(4021, usage());
   EXPECT_EQ(4000, unlimited_usage());
   EXPECT_EQ(10000000, quota());
   EXPECT_LE(0, available_space());
 }
 
 TEST_F(QuotaManagerTest, DeleteHostDataSimple) {
   static const MockOriginData kData[] = {
     { "http://foo.com/",   kTemp,     1 },
   };
-  MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData));
+  MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+      QuotaClient::kFileSystem);
   RegisterClient(client);
 
   GetGlobalUsage(kTemp);
   MessageLoop::current()->RunAllPending();
   const int64 predelete_global_tmp = usage();
 
   GetHostUsage("foo.com", kTemp);
   MessageLoop::current()->RunAllPending();
   int64 predelete_host_tmp = usage();
 
@@ skipping 41 matching lines @@
     { "http://foo.com/",   kPerm,   300 },
     { "http://bar.com/",   kTemp,  4000 },
   };
   static const MockOriginData kData2[] = {
     { "http://foo.com/",   kTemp, 50000 },
     { "http://foo.com:1/", kTemp,  6000 },
     { "http://foo.com/",   kPerm,   700 },
     { "https://foo.com/",  kTemp,    80 },
     { "http://bar.com/",   kTemp,     9 },
   };
-  MockStorageClient* client1 = CreateClient(kData1, ARRAYSIZE_UNSAFE(kData1));
-  MockStorageClient* client2 = CreateClient(kData2, ARRAYSIZE_UNSAFE(kData2));
+  MockStorageClient* client1 = CreateClient(kData1, ARRAYSIZE_UNSAFE(kData1),
+      QuotaClient::kFileSystem);
+  MockStorageClient* client2 = CreateClient(kData2, ARRAYSIZE_UNSAFE(kData2),
+      QuotaClient::kDatabase);
   RegisterClient(client1);
   RegisterClient(client2);
 
   GetGlobalUsage(kTemp);
   MessageLoop::current()->RunAllPending();
   const int64 predelete_global_tmp = usage();
 
   GetHostUsage("foo.com", kTemp);
   MessageLoop::current()->RunAllPending();
   const int64 predelete_foo_tmp = usage();
@@ skipping 64 matching lines @@
     { "http://foo.com/",   kPerm,   300 },
     { "http://bar.com/",   kTemp,  4000 },
   };
   static const MockOriginData kData2[] = {
     { "http://foo.com/",   kTemp, 50000 },
     { "http://foo.com:1/", kTemp,  6000 },
     { "http://foo.com/",   kPerm,   700 },
     { "https://foo.com/",  kTemp,    80 },
     { "http://bar.com/",   kTemp,     9 },
   };
-  MockStorageClient* client1 = CreateClient(kData1, ARRAYSIZE_UNSAFE(kData1));
-  MockStorageClient* client2 = CreateClient(kData2, ARRAYSIZE_UNSAFE(kData2));
+  MockStorageClient* client1 = CreateClient(kData1, ARRAYSIZE_UNSAFE(kData1),
+      QuotaClient::kFileSystem);
+  MockStorageClient* client2 = CreateClient(kData2, ARRAYSIZE_UNSAFE(kData2),
+      QuotaClient::kDatabase);
   RegisterClient(client1);
   RegisterClient(client2);
 
   GetGlobalUsage(kTemp);
   MessageLoop::current()->RunAllPending();
   const int64 predelete_global_tmp = usage();
 
   GetHostUsage("foo.com", kTemp);
   MessageLoop::current()->RunAllPending();
   const int64 predelete_foo_tmp = usage();
 
   GetHostUsage("bar.com", kTemp);
   MessageLoop::current()->RunAllPending();
   const int64 predelete_bar_tmp = usage();
 
   GetHostUsage("foo.com", kPerm);
   MessageLoop::current()->RunAllPending();
   const int64 predelete_foo_pers = usage();
 
   GetHostUsage("bar.com", kPerm);
   MessageLoop::current()->RunAllPending();
   const int64 predelete_bar_pers = usage();
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kData1); ++i)
-    quota_manager()->NotifyStorageAccessed(QuotaClient::kMockStart,
+    quota_manager()->NotifyStorageAccessed(QuotaClient::kUnknown,
         GURL(kData1[i].origin), kData1[i].type);
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kData2); ++i)
-    quota_manager()->NotifyStorageAccessed(QuotaClient::kMockStart,
+    quota_manager()->NotifyStorageAccessed(QuotaClient::kUnknown,
         GURL(kData2[i].origin), kData2[i].type);
   MessageLoop::current()->RunAllPending();
 
   reset_status_callback_count();
   DeleteOriginData(GURL("http://foo.com/"), kTemp, kAllClients);
   DeleteOriginData(GURL("http://bar.com/"), kTemp, kAllClients);
   DeleteOriginData(GURL("http://foo.com/"), kTemp, kAllClients);
   MessageLoop::current()->RunAllPending();
 
   EXPECT_EQ(3, status_callback_count());
@@ skipping 32 matching lines @@
   EXPECT_EQ(predelete_bar_pers, usage());
 }
 
 TEST_F(QuotaManagerTest, GetCachedOrigins) {
   static const MockOriginData kData[] = {
     { "http://a.com/",   kTemp,       1 },
     { "http://a.com:1/", kTemp,      20 },
     { "http://b.com/",   kPerm,     300 },
     { "http://c.com/",   kTemp,    4000 },
   };
-  MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData));
+  MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+      QuotaClient::kFileSystem);
   RegisterClient(client);
 
   // TODO(kinuko): Be careful when we add cache pruner.
 
   std::set<GURL> origins;
   GetCachedOrigins(kTemp, &origins);
   EXPECT_TRUE(origins.empty());
 
   // No matter how we make queries the quota manager tries to cache all
   // the origins at startup.
@@ skipping 22 matching lines @@
 }
 
 TEST_F(QuotaManagerTest, NotifyAndLRUOrigin) {
   static const MockOriginData kData[] = {
     { "http://a.com/",   kTemp,  0 },
     { "http://a.com:1/", kTemp,  0 },
     { "https://a.com/",  kTemp,  0 },
     { "http://b.com/",   kPerm,  0 },  // persistent
     { "http://c.com/",   kTemp,  0 },
   };
-  MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData));
+  MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+      QuotaClient::kFileSystem);
   RegisterClient(client);
 
   GURL origin;
   GetLRUOrigin(kTemp);
   MessageLoop::current()->RunAllPending();
   EXPECT_TRUE(lru_origin().is_empty());
 
   NotifyStorageAccessed(client, GURL("http://a.com/"), kTemp);
   GetLRUOrigin(kTemp);
   MessageLoop::current()->RunAllPending();
@@ skipping 18 matching lines @@
 }
 
 TEST_F(QuotaManagerTest, GetLRUOriginWithOriginInUse) {
   static const MockOriginData kData[] = {
     { "http://a.com/",   kTemp,  0 },
     { "http://a.com:1/", kTemp,  0 },
     { "https://a.com/",  kTemp,  0 },
     { "http://b.com/",   kPerm,  0 },  // persistent
     { "http://c.com/",   kTemp,  0 },
   };
-  MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData));
+  MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+      QuotaClient::kFileSystem);
   RegisterClient(client);
 
   GURL origin;
   GetLRUOrigin(kTemp);
   MessageLoop::current()->RunAllPending();
   EXPECT_TRUE(lru_origin().is_empty());
 
   NotifyStorageAccessed(client, GURL("http://a.com/"), kTemp);
   NotifyStorageAccessed(client, GURL("http://b.com/"), kPerm);
   NotifyStorageAccessed(client, GURL("https://a.com/"), kTemp);
@@ skipping 33 matching lines @@
 }
 
 TEST_F(QuotaManagerTest, GetOriginsModifiedSince) {
   static const MockOriginData kData[] = {
     { "http://a.com/",   kTemp,  0 },
     { "http://a.com:1/", kTemp,  0 },
     { "https://a.com/",  kTemp,  0 },
     { "http://b.com/",   kPerm,  0 },  // persistent
     { "http://c.com/",   kTemp,  0 },
   };
-  MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData));
+  MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+      QuotaClient::kFileSystem);
   RegisterClient(client);
 
   GetOriginsModifiedSince(kTemp, base::Time());
   MessageLoop::current()->RunAllPending();
   EXPECT_TRUE(modified_origins().empty());
   EXPECT_EQ(modified_origins_type(), kTemp);
 
   base::Time time1 = client->IncrementMockTime();
   client->ModifyOriginAndNotify(GURL("http://a.com/"), kTemp, 10);
   client->ModifyOriginAndNotify(GURL("http://a.com:1/"), kTemp, 10);
@@ skipping 55 matching lines @@
                  << "quota = " << itr->quota);
     EXPECT_EQ(1u, entries.erase(*itr));
   }
   EXPECT_TRUE(entries.empty());
 }
 
 TEST_F(QuotaManagerTest, DumpOriginInfoTable) {
   using std::make_pair;
 
   quota_manager()->NotifyStorageAccessed(
-      QuotaClient::kMockStart,
+      QuotaClient::kUnknown,
       GURL("http://example.com/"),
       kTemp);
   quota_manager()->NotifyStorageAccessed(
-      QuotaClient::kMockStart,
+      QuotaClient::kUnknown,
       GURL("http://example.com/"),
       kPerm);
   quota_manager()->NotifyStorageAccessed(
-      QuotaClient::kMockStart,
+      QuotaClient::kUnknown,
       GURL("http://example.com/"),
       kPerm);
   MessageLoop::current()->RunAllPending();
 
   DumpOriginInfoTable();
   MessageLoop::current()->RunAllPending();
 
   typedef std::pair<GURL, StorageType> TypedOrigin;
   typedef std::pair<TypedOrigin, int> Entry;
   const Entry kEntries[] = {
@@ skipping 223 matching lines @@
   EXPECT_EQ(predelete_foo_tmp - 2 - 1, usage());
 
   DeleteHostData("foo.com", kTemp,
       QuotaClient::kDatabase | QuotaClient::kIndexedDatabase);
   MessageLoop::current()->RunAllPending();
   GetHostUsage("foo.com", kTemp);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(predelete_foo_tmp - 8 - 4 - 2 - 1, usage());
 }
 }  // namespace quota