content/browser/fileapi/file_system_quota_client_unittest.cc

   1 // Copyright 2013 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/basictypes.h"
   6 #include "base/bind.h"
   7 #include "base/file_util.h"
   8 #include "base/files/scoped_temp_dir.h"
   9 #include "base/message_loop/message_loop_proxy.h"
  10 #include "base/run_loop.h"
  11 #include "content/public/test/async_file_test_helper.h"
  12 #include "content/public/test/test_file_system_context.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14 #include "url/gurl.h"
  15 #include "webkit/browser/fileapi/file_system_context.h"
  16 #include "webkit/browser/fileapi/file_system_quota_client.h"
  17 #include "webkit/browser/fileapi/file_system_usage_cache.h"
  18 #include "webkit/browser/fileapi/obfuscated_file_util.h"
  19 #include "webkit/common/fileapi/file_system_types.h"
  20 #include "webkit/common/fileapi/file_system_util.h"
  21 #include "webkit/common/quota/quota_types.h"
  22
  23 using content::AsyncFileTestHelper;
  24 using storage::FileSystemQuotaClient;
  25 using storage::FileSystemURL;
  26
  27 namespace content {
  28 namespace {
  29
  30 const char kDummyURL1[] = "http://www.dummy.org";
  31 const char kDummyURL2[] = "http://www.example.com";
  32 const char kDummyURL3[] = "http://www.bleh";
  33
  34 // Declared to shorten the variable names.
  35 const storage::StorageType kTemporary = storage::kStorageTypeTemporary;
  36 const storage::StorageType kPersistent = storage::kStorageTypePersistent;
  37
  38 }  // namespace
  39
  40 class FileSystemQuotaClientTest : public testing::Test {
  41  public:
  42   FileSystemQuotaClientTest()
  43       : weak_factory_(this),
  44         additional_callback_count_(0),
  45         deletion_status_(storage::kQuotaStatusUnknown) {}
  46
  47   virtual void SetUp() {
  48     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
  49     file_system_context_ = CreateFileSystemContextForTesting(
  50             NULL, data_dir_.path());
  51   }
  52
  53   struct TestFile {
  54     bool isDirectory;
  55     const char* name;
  56     int64 size;
  57     const char* origin_url;
  58     storage::StorageType type;
  59   };
  60
  61  protected:
  62   FileSystemQuotaClient* NewQuotaClient(bool is_incognito) {
  63     return new FileSystemQuotaClient(file_system_context_.get(), is_incognito);
  64   }
  65
  66   void GetOriginUsageAsync(FileSystemQuotaClient* quota_client,
  67                            const std::string& origin_url,
  68                            storage::StorageType type) {
  69     quota_client->GetOriginUsage(
  70         GURL(origin_url), type,
  71         base::Bind(&FileSystemQuotaClientTest::OnGetUsage,
  72                    weak_factory_.GetWeakPtr()));
  73   }
  74
  75   int64 GetOriginUsage(FileSystemQuotaClient* quota_client,
  76                        const std::string& origin_url,
  77                        storage::StorageType type) {
  78     GetOriginUsageAsync(quota_client, origin_url, type);
  79     base::RunLoop().RunUntilIdle();
  80     return usage_;
  81   }
  82
  83   const std::set<GURL>& GetOriginsForType(FileSystemQuotaClient* quota_client,
  84                                           storage::StorageType type) {
  85     origins_.clear();
  86     quota_client->GetOriginsForType(
  87         type,
  88         base::Bind(&FileSystemQuotaClientTest::OnGetOrigins,
  89                    weak_factory_.GetWeakPtr()));
  90     base::RunLoop().RunUntilIdle();
  91     return origins_;
  92   }
  93
  94   const std::set<GURL>& GetOriginsForHost(FileSystemQuotaClient* quota_client,
  95                                           storage::StorageType type,
  96                                           const std::string& host) {
  97     origins_.clear();
  98     quota_client->GetOriginsForHost(
  99         type, host,
 100         base::Bind(&FileSystemQuotaClientTest::OnGetOrigins,
 101                    weak_factory_.GetWeakPtr()));
 102     base::RunLoop().RunUntilIdle();
 103     return origins_;
 104   }
 105
 106   void RunAdditionalOriginUsageTask(FileSystemQuotaClient* quota_client,
 107                                     const std::string& origin_url,
 108                                     storage::StorageType type) {
 109     quota_client->GetOriginUsage(
 110         GURL(origin_url), type,
 111         base::Bind(&FileSystemQuotaClientTest::OnGetAdditionalUsage,
 112                    weak_factory_.GetWeakPtr()));
 113   }
 114
 115   bool CreateFileSystemDirectory(const base::FilePath& file_path,
 116                                  const std::string& origin_url,
 117                                  storage::StorageType storage_type) {
 118     storage::FileSystemType type =
 119         storage::QuotaStorageTypeToFileSystemType(storage_type);
 120     FileSystemURL url = file_system_context_->CreateCrackedFileSystemURL(
 121         GURL(origin_url), type, file_path);
 122
 123     base::File::Error result =
 124         AsyncFileTestHelper::CreateDirectory(file_system_context_.get(), url);
 125     return result == base::File::FILE_OK;
 126   }
 127
 128   bool CreateFileSystemFile(const base::FilePath& file_path,
 129                             int64 file_size,
 130                             const std::string& origin_url,
 131                             storage::StorageType storage_type) {
 132     if (file_path.empty())
 133       return false;
 134
 135     storage::FileSystemType type =
 136         storage::QuotaStorageTypeToFileSystemType(storage_type);
 137     FileSystemURL url = file_system_context_->CreateCrackedFileSystemURL(
 138         GURL(origin_url), type, file_path);
 139
 140     base::File::Error result =
 141         AsyncFileTestHelper::CreateFile(file_system_context_.get(), url);
 142     if (result != base::File::FILE_OK)
 143       return false;
 144
 145     result = AsyncFileTestHelper::TruncateFile(
 146         file_system_context_.get(), url, file_size);
 147     return result == base::File::FILE_OK;
 148   }
 149
 150   void InitializeOriginFiles(FileSystemQuotaClient* quota_client,
 151                              const TestFile* files,
 152                              int num_files) {
 153     for (int i = 0; i < num_files; i++) {
 154       base::FilePath path = base::FilePath().AppendASCII(files[i].name);
 155       if (files[i].isDirectory) {
 156         ASSERT_TRUE(CreateFileSystemDirectory(
 157             path, files[i].origin_url, files[i].type));
 158         if (path.empty()) {
 159           // Create the usage cache.
 160           // HACK--we always create the root [an empty path] first.  If we
 161           // create it later, this will fail due to a quota mismatch.  If we
 162           // call this before we create the root, it succeeds, but hasn't
 163           // actually created the cache.
 164           ASSERT_EQ(0, GetOriginUsage(
 165               quota_client, files[i].origin_url, files[i].type));
 166         }
 167       } else {
 168         ASSERT_TRUE(CreateFileSystemFile(
 169             path, files[i].size, files[i].origin_url, files[i].type));
 170       }
 171     }
 172   }
 173
 174   // This is a bit fragile--it depends on the test data always creating a
 175   // directory before adding a file or directory to it, so that we can just
 176   // count the basename of each addition.  A recursive creation of a path, which
 177   // created more than one directory in a single shot, would break this.
 178   int64 ComputeFilePathsCostForOriginAndType(const TestFile* files,
 179                                              int num_files,
 180                                              const std::string& origin_url,
 181                                              storage::StorageType type) {
 182     int64 file_paths_cost = 0;
 183     for (int i = 0; i < num_files; i++) {
 184       if (files[i].type == type &&
 185           GURL(files[i].origin_url) == GURL(origin_url)) {
 186         base::FilePath path = base::FilePath().AppendASCII(files[i].name);
 187         if (!path.empty()) {
 188           file_paths_cost +=
 189               storage::ObfuscatedFileUtil::ComputeFilePathCost(path);
 190         }
 191       }
 192     }
 193     return file_paths_cost;
 194   }
 195
 196   void DeleteOriginData(FileSystemQuotaClient* quota_client,
 197                         const std::string& origin,
 198                         storage::StorageType type) {
 199     deletion_status_ = storage::kQuotaStatusUnknown;
 200     quota_client->DeleteOriginData(
 201         GURL(origin), type,
 202         base::Bind(&FileSystemQuotaClientTest::OnDeleteOrigin,
 203                    weak_factory_.GetWeakPtr()));
 204   }
 205
 206   int64 usage() const { return usage_; }
 207   storage::QuotaStatusCode status() { return deletion_status_; }
 208   int additional_callback_count() const { return additional_callback_count_; }
 209   void set_additional_callback_count(int count) {
 210     additional_callback_count_ = count;
 211   }
 212
 213  private:
 214   void OnGetUsage(int64 usage) {
 215     usage_ = usage;
 216   }
 217
 218   void OnGetOrigins(const std::set<GURL>& origins) {
 219     origins_ = origins;
 220   }
 221
 222   void OnGetAdditionalUsage(int64 usage_unused) {
 223     ++additional_callback_count_;
 224   }
 225
 226   void OnDeleteOrigin(storage::QuotaStatusCode status) {
 227     deletion_status_ = status;
 228   }
 229
 230   base::ScopedTempDir data_dir_;
 231   base::MessageLoop message_loop_;
 232   scoped_refptr<storage::FileSystemContext> file_system_context_;
 233   base::WeakPtrFactory<FileSystemQuotaClientTest> weak_factory_;
 234   int64 usage_;
 235   int additional_callback_count_;
 236   std::set<GURL> origins_;
 237   storage::QuotaStatusCode deletion_status_;
 238
 239   DISALLOW_COPY_AND_ASSIGN(FileSystemQuotaClientTest);
 240 };
 241
 242 TEST_F(FileSystemQuotaClientTest, NoFileSystemTest) {
 243   scoped_ptr<FileSystemQuotaClient> quota_client(NewQuotaClient(false));
 244
 245   EXPECT_EQ(0, GetOriginUsage(quota_client.get(), kDummyURL1, kTemporary));
 246 }
 247
 248 TEST_F(FileSystemQuotaClientTest, NoFileTest) {
 249   scoped_ptr<FileSystemQuotaClient> quota_client(NewQuotaClient(false));
 250   const TestFile kFiles[] = {
 251     {true, NULL, 0, kDummyURL1, kTemporary},
 252   };
 253   InitializeOriginFiles(quota_client.get(), kFiles, ARRAYSIZE_UNSAFE(kFiles));
 254
 255   for (int i = 0; i < 2; i++) {
 256     EXPECT_EQ(0, GetOriginUsage(quota_client.get(), kDummyURL1, kTemporary));
 257   }
 258 }
 259
 260 TEST_F(FileSystemQuotaClientTest, OneFileTest) {
 261   scoped_ptr<FileSystemQuotaClient> quota_client(NewQuotaClient(false));
 262   const TestFile kFiles[] = {
 263     {true, NULL, 0, kDummyURL1, kTemporary},
 264     {false, "foo", 4921, kDummyURL1, kTemporary},
 265   };
 266   InitializeOriginFiles(quota_client.get(), kFiles, ARRAYSIZE_UNSAFE(kFiles));
 267   const int64 file_paths_cost = ComputeFilePathsCostForOriginAndType(
 268       kFiles, ARRAYSIZE_UNSAFE(kFiles), kDummyURL1, kTemporary);
 269
 270   for (int i = 0; i < 2; i++) {
 271     EXPECT_EQ(4921 + file_paths_cost,
 272         GetOriginUsage(quota_client.get(), kDummyURL1, kTemporary));
 273   }
 274 }
 275
 276 TEST_F(FileSystemQuotaClientTest, TwoFilesTest) {
 277   scoped_ptr<FileSystemQuotaClient> quota_client(NewQuotaClient(false));
 278   const TestFile kFiles[] = {
 279     {true, NULL, 0, kDummyURL1, kTemporary},
 280     {false, "foo", 10310, kDummyURL1, kTemporary},
 281     {false, "bar", 41, kDummyURL1, kTemporary},
 282   };
 283   InitializeOriginFiles(quota_client.get(), kFiles, ARRAYSIZE_UNSAFE(kFiles));
 284   const int64 file_paths_cost = ComputeFilePathsCostForOriginAndType(
 285       kFiles, ARRAYSIZE_UNSAFE(kFiles), kDummyURL1, kTemporary);
 286
 287   for (int i = 0; i < 2; i++) {
 288     EXPECT_EQ(10310 + 41 + file_paths_cost,
 289         GetOriginUsage(quota_client.get(), kDummyURL1, kTemporary));
 290   }
 291 }
 292
 293 TEST_F(FileSystemQuotaClientTest, EmptyFilesTest) {
 294   scoped_ptr<FileSystemQuotaClient> quota_client(NewQuotaClient(false));
 295   const TestFile kFiles[] = {
 296     {true, NULL, 0, kDummyURL1, kTemporary},
 297     {false, "foo", 0, kDummyURL1, kTemporary},
 298     {false, "bar", 0, kDummyURL1, kTemporary},
 299     {false, "baz", 0, kDummyURL1, kTemporary},
 300   };
 301   InitializeOriginFiles(quota_client.get(), kFiles, ARRAYSIZE_UNSAFE(kFiles));
 302   const int64 file_paths_cost = ComputeFilePathsCostForOriginAndType(
 303       kFiles, ARRAYSIZE_UNSAFE(kFiles), kDummyURL1, kTemporary);
 304
 305   for (int i = 0; i < 2; i++) {
 306     EXPECT_EQ(file_paths_cost,
 307         GetOriginUsage(quota_client.get(), kDummyURL1, kTemporary));
 308   }
 309 }
 310
 311 TEST_F(FileSystemQuotaClientTest, SubDirectoryTest) {
 312   scoped_ptr<FileSystemQuotaClient> quota_client(NewQuotaClient(false));
 313   const TestFile kFiles[] = {
 314     {true, NULL, 0, kDummyURL1, kTemporary},
 315     {true, "dirtest", 0, kDummyURL1, kTemporary},
 316     {false, "dirtest/foo", 11921, kDummyURL1, kTemporary},
 317     {false, "bar", 4814, kDummyURL1, kTemporary},
 318   };
 319   InitializeOriginFiles(quota_client.get(), kFiles, ARRAYSIZE_UNSAFE(kFiles));
 320   const int64 file_paths_cost = ComputeFilePathsCostForOriginAndType(
 321       kFiles, ARRAYSIZE_UNSAFE(kFiles), kDummyURL1, kTemporary);
 322
 323   for (int i = 0; i < 2; i++) {
 324     EXPECT_EQ(11921 + 4814 + file_paths_cost,
 325         GetOriginUsage(quota_client.get(), kDummyURL1, kTemporary));
 326   }
 327 }
 328
 329 TEST_F(FileSystemQuotaClientTest, MultiTypeTest) {
 330   scoped_ptr<FileSystemQuotaClient> quota_client(NewQuotaClient(false));
 331   const TestFile kFiles[] = {
 332     {true, NULL, 0, kDummyURL1, kTemporary},
 333     {true, "dirtest", 0, kDummyURL1, kTemporary},
 334     {false, "dirtest/foo", 133, kDummyURL1, kTemporary},
 335     {false, "bar", 14, kDummyURL1, kTemporary},
 336     {true, NULL, 0, kDummyURL1, kPersistent},
 337     {true, "dirtest", 0, kDummyURL1, kPersistent},
 338     {false, "dirtest/foo", 193, kDummyURL1, kPersistent},
 339     {false, "bar", 9, kDummyURL1, kPersistent},
 340   };
 341   InitializeOriginFiles(quota_client.get(), kFiles, ARRAYSIZE_UNSAFE(kFiles));
 342   const int64 file_paths_cost_temporary = ComputeFilePathsCostForOriginAndType(
 343       kFiles, ARRAYSIZE_UNSAFE(kFiles), kDummyURL1, kTemporary);
 344   const int64 file_paths_cost_persistent = ComputeFilePathsCostForOriginAndType(
 345       kFiles, ARRAYSIZE_UNSAFE(kFiles), kDummyURL1, kTemporary);
 346
 347   for (int i = 0; i < 2; i++) {
 348     EXPECT_EQ(133 + 14 + file_paths_cost_temporary,
 349         GetOriginUsage(quota_client.get(), kDummyURL1, kTemporary));
 350     EXPECT_EQ(193 + 9 + file_paths_cost_persistent,
 351         GetOriginUsage(quota_client.get(), kDummyURL1, kPersistent));
 352   }
 353 }
 354
 355 TEST_F(FileSystemQuotaClientTest, MultiDomainTest) {
 356   scoped_ptr<FileSystemQuotaClient> quota_client(NewQuotaClient(false));
 357   const TestFile kFiles[] = {
 358     {true, NULL, 0, kDummyURL1, kTemporary},
 359     {true, "dir1", 0, kDummyURL1, kTemporary},
 360     {false, "dir1/foo", 1331, kDummyURL1, kTemporary},
 361     {false, "bar", 134, kDummyURL1, kTemporary},
 362     {true, NULL, 0, kDummyURL1, kPersistent},
 363     {true, "dir2", 0, kDummyURL1, kPersistent},
 364     {false, "dir2/foo", 1903, kDummyURL1, kPersistent},
 365     {false, "bar", 19, kDummyURL1, kPersistent},
 366     {true, NULL, 0, kDummyURL2, kTemporary},
 367     {true, "dom", 0, kDummyURL2, kTemporary},
 368     {false, "dom/fan", 1319, kDummyURL2, kTemporary},
 369     {false, "bar", 113, kDummyURL2, kTemporary},
 370     {true, NULL, 0, kDummyURL2, kPersistent},
 371     {true, "dom", 0, kDummyURL2, kPersistent},
 372     {false, "dom/fan", 2013, kDummyURL2, kPersistent},
 373     {false, "baz", 18, kDummyURL2, kPersistent},
 374   };
 375   InitializeOriginFiles(quota_client.get(), kFiles, ARRAYSIZE_UNSAFE(kFiles));
 376   const int64 file_paths_cost_temporary1 = ComputeFilePathsCostForOriginAndType(
 377       kFiles, ARRAYSIZE_UNSAFE(kFiles), kDummyURL1, kTemporary);
 378   const int64 file_paths_cost_persistent1 =
 379       ComputeFilePathsCostForOriginAndType(kFiles, ARRAYSIZE_UNSAFE(kFiles),
 380           kDummyURL1, kPersistent);
 381   const int64 file_paths_cost_temporary2 = ComputeFilePathsCostForOriginAndType(
 382       kFiles, ARRAYSIZE_UNSAFE(kFiles), kDummyURL2, kTemporary);
 383   const int64 file_paths_cost_persistent2 =
 384       ComputeFilePathsCostForOriginAndType(kFiles, ARRAYSIZE_UNSAFE(kFiles),
 385           kDummyURL2, kPersistent);
 386
 387   for (int i = 0; i < 2; i++) {
 388     EXPECT_EQ(1331 + 134 + file_paths_cost_temporary1,
 389         GetOriginUsage(quota_client.get(), kDummyURL1, kTemporary));
 390     EXPECT_EQ(1903 + 19 + file_paths_cost_persistent1,
 391         GetOriginUsage(quota_client.get(), kDummyURL1, kPersistent));
 392     EXPECT_EQ(1319 + 113 + file_paths_cost_temporary2,
 393         GetOriginUsage(quota_client.get(), kDummyURL2, kTemporary));
 394     EXPECT_EQ(2013 + 18 + file_paths_cost_persistent2,
 395         GetOriginUsage(quota_client.get(), kDummyURL2, kPersistent));
 396   }
 397 }
 398
 399 TEST_F(FileSystemQuotaClientTest, GetUsage_MultipleTasks) {
 400   scoped_ptr<FileSystemQuotaClient> quota_client(NewQuotaClient(false));
 401   const TestFile kFiles[] = {
 402     {true, NULL, 0, kDummyURL1, kTemporary},
 403     {false, "foo",   11, kDummyURL1, kTemporary},
 404     {false, "bar",   22, kDummyURL1, kTemporary},
 405   };
 406   InitializeOriginFiles(quota_client.get(), kFiles, ARRAYSIZE_UNSAFE(kFiles));
 407   const int64 file_paths_cost = ComputeFilePathsCostForOriginAndType(
 408       kFiles, ARRAYSIZE_UNSAFE(kFiles), kDummyURL1, kTemporary);
 409
 410   // Dispatching three GetUsage tasks.
 411   set_additional_callback_count(0);
 412   GetOriginUsageAsync(quota_client.get(), kDummyURL1, kTemporary);
 413   RunAdditionalOriginUsageTask(quota_client.get(), kDummyURL1, kTemporary);
 414   RunAdditionalOriginUsageTask(quota_client.get(), kDummyURL1, kTemporary);
 415   base::RunLoop().RunUntilIdle();
 416   EXPECT_EQ(11 + 22 + file_paths_cost, usage());
 417   EXPECT_EQ(2, additional_callback_count());
 418
 419   // Once more, in a different order.
 420   set_additional_callback_count(0);
 421   RunAdditionalOriginUsageTask(quota_client.get(), kDummyURL1, kTemporary);
 422   GetOriginUsageAsync(quota_client.get(), kDummyURL1, kTemporary);
 423   RunAdditionalOriginUsageTask(quota_client.get(), kDummyURL1, kTemporary);
 424   base::RunLoop().RunUntilIdle();
 425   EXPECT_EQ(11 + 22 + file_paths_cost, usage());
 426   EXPECT_EQ(2, additional_callback_count());
 427 }
 428
 429 TEST_F(FileSystemQuotaClientTest, GetOriginsForType) {
 430   scoped_ptr<FileSystemQuotaClient> quota_client(NewQuotaClient(false));
 431   const TestFile kFiles[] = {
 432     {true, NULL, 0, kDummyURL1, kTemporary},
 433     {true, NULL, 0, kDummyURL2, kTemporary},
 434     {true, NULL, 0, kDummyURL3, kPersistent},
 435   };
 436   InitializeOriginFiles(quota_client.get(), kFiles, ARRAYSIZE_UNSAFE(kFiles));
 437
 438   std::set<GURL> origins = GetOriginsForType(quota_client.get(), kTemporary);
 439   EXPECT_EQ(2U, origins.size());
 440   EXPECT_TRUE(origins.find(GURL(kDummyURL1)) != origins.end());
 441   EXPECT_TRUE(origins.find(GURL(kDummyURL2)) != origins.end());
 442   EXPECT_TRUE(origins.find(GURL(kDummyURL3)) == origins.end());
 443 }
 444
 445 TEST_F(FileSystemQuotaClientTest, GetOriginsForHost) {
 446   scoped_ptr<FileSystemQuotaClient> quota_client(NewQuotaClient(false));
 447   const char* kURL1 = "http://foo.com/";
 448   const char* kURL2 = "https://foo.com/";
 449   const char* kURL3 = "http://foo.com:1/";
 450   const char* kURL4 = "http://foo2.com/";
 451   const char* kURL5 = "http://foo.com:2/";
 452   const TestFile kFiles[] = {
 453     {true, NULL, 0, kURL1, kTemporary},
 454     {true, NULL, 0, kURL2, kTemporary},
 455     {true, NULL, 0, kURL3, kTemporary},
 456     {true, NULL, 0, kURL4, kTemporary},
 457     {true, NULL, 0, kURL5, kPersistent},
 458   };
 459   InitializeOriginFiles(quota_client.get(), kFiles, ARRAYSIZE_UNSAFE(kFiles));
 460
 461   std::set<GURL> origins = GetOriginsForHost(
 462       quota_client.get(), kTemporary, "foo.com");
 463   EXPECT_EQ(3U, origins.size());
 464   EXPECT_TRUE(origins.find(GURL(kURL1)) != origins.end());
 465   EXPECT_TRUE(origins.find(GURL(kURL2)) != origins.end());
 466   EXPECT_TRUE(origins.find(GURL(kURL3)) != origins.end());
 467   EXPECT_TRUE(origins.find(GURL(kURL4)) == origins.end());  // Different host.
 468   EXPECT_TRUE(origins.find(GURL(kURL5)) == origins.end());  // Different type.
 469 }
 470
 471 TEST_F(FileSystemQuotaClientTest, IncognitoTest) {
 472   scoped_ptr<FileSystemQuotaClient> quota_client(NewQuotaClient(true));
 473   const TestFile kFiles[] = {
 474     {true, NULL, 0, kDummyURL1, kTemporary},
 475     {false, "foo", 10, kDummyURL1, kTemporary},
 476   };
 477   InitializeOriginFiles(quota_client.get(), kFiles, ARRAYSIZE_UNSAFE(kFiles));
 478
 479   // Having files in the usual directory wouldn't affect the result
 480   // queried in incognito mode.
 481   EXPECT_EQ(0, GetOriginUsage(quota_client.get(), kDummyURL1, kTemporary));
 482   EXPECT_EQ(0, GetOriginUsage(quota_client.get(), kDummyURL1, kPersistent));
 483
 484   std::set<GURL> origins = GetOriginsForType(quota_client.get(), kTemporary);
 485   EXPECT_EQ(0U, origins.size());
 486   origins = GetOriginsForHost(quota_client.get(), kTemporary, "www.dummy.org");
 487   EXPECT_EQ(0U, origins.size());
 488 }
 489
 490 TEST_F(FileSystemQuotaClientTest, DeleteOriginTest) {
 491   scoped_ptr<FileSystemQuotaClient> quota_client(NewQuotaClient(false));
 492   const TestFile kFiles[] = {
 493     {true, NULL,  0, "http://foo.com/",  kTemporary},
 494     {false, "a",  1, "http://foo.com/",  kTemporary},
 495     {true, NULL,  0, "https://foo.com/", kTemporary},
 496     {false, "b",  2, "https://foo.com/", kTemporary},
 497     {true, NULL,  0, "http://foo.com/",  kPersistent},
 498     {false, "c",  4, "http://foo.com/",  kPersistent},
 499     {true, NULL,  0, "http://bar.com/",  kTemporary},
 500     {false, "d",  8, "http://bar.com/",  kTemporary},
 501     {true, NULL,  0, "http://bar.com/",  kPersistent},
 502     {false, "e", 16, "http://bar.com/",  kPersistent},
 503     {true, NULL,  0, "https://bar.com/", kPersistent},
 504     {false, "f", 32, "https://bar.com/", kPersistent},
 505     {true, NULL,  0, "https://bar.com/", kTemporary},
 506     {false, "g", 64, "https://bar.com/", kTemporary},
 507   };
 508   InitializeOriginFiles(quota_client.get(), kFiles, ARRAYSIZE_UNSAFE(kFiles));
 509   const int64 file_paths_cost_temporary_foo_https =
 510       ComputeFilePathsCostForOriginAndType(kFiles, ARRAYSIZE_UNSAFE(kFiles),
 511           "https://foo.com/", kTemporary);
 512   const int64 file_paths_cost_persistent_foo =
 513       ComputeFilePathsCostForOriginAndType(kFiles, ARRAYSIZE_UNSAFE(kFiles),
 514           "http://foo.com/", kPersistent);
 515   const int64 file_paths_cost_temporary_bar =
 516       ComputeFilePathsCostForOriginAndType(kFiles, ARRAYSIZE_UNSAFE(kFiles),
 517           "http://bar.com/", kTemporary);
 518   const int64 file_paths_cost_temporary_bar_https =
 519       ComputeFilePathsCostForOriginAndType(kFiles, ARRAYSIZE_UNSAFE(kFiles),
 520           "https://bar.com/", kTemporary);
 521   const int64 file_paths_cost_persistent_bar_https =
 522       ComputeFilePathsCostForOriginAndType(kFiles, ARRAYSIZE_UNSAFE(kFiles),
 523           "https://bar.com/", kPersistent);
 524
 525   DeleteOriginData(quota_client.get(), "http://foo.com/", kTemporary);
 526   base::RunLoop().RunUntilIdle();
 527   EXPECT_EQ(storage::kQuotaStatusOk, status());
 528
 529   DeleteOriginData(quota_client.get(), "http://bar.com/", kPersistent);
 530   base::RunLoop().RunUntilIdle();
 531   EXPECT_EQ(storage::kQuotaStatusOk, status());
 532
 533   DeleteOriginData(quota_client.get(), "http://buz.com/", kTemporary);
 534   base::RunLoop().RunUntilIdle();
 535   EXPECT_EQ(storage::kQuotaStatusOk, status());
 536
 537   EXPECT_EQ(0, GetOriginUsage(
 538       quota_client.get(), "http://foo.com/", kTemporary));
 539   EXPECT_EQ(0, GetOriginUsage(
 540       quota_client.get(), "http://bar.com/", kPersistent));
 541   EXPECT_EQ(0, GetOriginUsage(
 542       quota_client.get(), "http://buz.com/", kTemporary));
 543
 544   EXPECT_EQ(2 + file_paths_cost_temporary_foo_https,
 545             GetOriginUsage(quota_client.get(),
 546                            "https://foo.com/",
 547                            kTemporary));
 548   EXPECT_EQ(4 + file_paths_cost_persistent_foo,
 549             GetOriginUsage(quota_client.get(),
 550                            "http://foo.com/",
 551                            kPersistent));
 552   EXPECT_EQ(8 + file_paths_cost_temporary_bar,
 553             GetOriginUsage(quota_client.get(),
 554                            "http://bar.com/",
 555                            kTemporary));
 556   EXPECT_EQ(32 + file_paths_cost_persistent_bar_https,
 557             GetOriginUsage(quota_client.get(),
 558                            "https://bar.com/",
 559                            kPersistent));
 560   EXPECT_EQ(64 + file_paths_cost_temporary_bar_https,
 561             GetOriginUsage(quota_client.get(),
 562                            "https://bar.com/",
 563                            kTemporary));
 564 }
 565
 566 }  // namespace content