Added DeleteOriginData to QuotaClient

webkit/fileapi/sandbox_quota_client_unittest.cc

 // Copyright (c) 2011 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 "base/basictypes.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_callback_factory.h"
 #include "base/memory/scoped_temp_dir.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
@@ skipping 15 matching lines @@
 const char kDummyURL2[] = "http://www.example.com";
 const char kDummyURL3[] = "http://www.bleh";
 
 // Declared to shorten the variable names.
 const quota::StorageType kTemporary = quota::kStorageTypeTemporary;
 const quota::StorageType kPersistent = quota::kStorageTypePersistent;
 const int kUsageFileSize = FileSystemUsageCache::kUsageFileSize;
 
 class MockFileSystemPathManager : public FileSystemPathManager {
  public:
-  MockFileSystemPathManager(const FilePath& filesystem_path)
+  explicit MockFileSystemPathManager(const FilePath& filesystem_path)
       : FileSystemPathManager(base::MessageLoopProxy::CreateForCurrentThread(),
                               filesystem_path, NULL, false, true) {}
 };
 
 }  // namespace
 
 class SandboxQuotaClientTest : public testing::Test {
  public:
   SandboxQuotaClientTest()
       : callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
-        additional_callback_count_(0) {
+        additional_callback_count_(0),
+        deletion_status_(quota::kQuotaStatusUnknown) {
   }
 
   void SetUp() {
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
     file_system_context_ =
         new FileSystemContext(
             base::MessageLoopProxy::CreateForCurrentThread(),
             base::MessageLoopProxy::CreateForCurrentThread(),
             NULL, NULL,
             FilePath(), false /* is_incognito */,
@@ skipping 112 matching lines @@
       if (files[i].isDirectory) {
         ASSERT_TRUE(CreateFileSystemDirectory(
             files[i].name, files[i].origin_url, files[i].type));
       } else {
         ASSERT_TRUE(CreateFileSystemFile(
             files[i].name, files[i].size, files[i].origin_url, files[i].type));
       }
     }
   }
 
+  void DeleteOriginData(SandboxQuotaClient* quota_client,
+                        const char* origin,
+                        quota::StorageType type) {
+    deletion_status_ = quota::kQuotaStatusUnknown;
+    quota_client->DeleteOriginData(
+        GURL(origin), type,
+        callback_factory_.NewCallback(
+            &SandboxQuotaClientTest::OnDeleteOrigin));
+  }
+
   int64 usage() const { return usage_; }
+  quota::QuotaStatusCode status() { return deletion_status_; }
   int additional_callback_count() const { return additional_callback_count_; }
   void set_additional_callback_count(int count) {
     additional_callback_count_ = count;
   }
 
  private:
   void OnGetUsage(int64 usage) {
     usage_ = usage;
   }
 
   void OnGetOrigins(const std::set<GURL>& origins) {
     origins_ = origins;
   }
 
-  void OnGetAdditionalUsage(int64) {
+  void OnGetAdditionalUsage(int64 usage_unused) {
     ++additional_callback_count_;
   }
 
+  void OnDeleteOrigin(quota::QuotaStatusCode status) {
+    deletion_status_ = status;
+  }
+
   ScopedTempDir data_dir_;
   scoped_refptr<FileSystemContext> file_system_context_;
   base::ScopedCallbackFactory<SandboxQuotaClientTest> callback_factory_;
   int64 usage_;
   int additional_callback_count_;
   std::set<GURL> origins_;
+  quota::QuotaStatusCode deletion_status_;
 
   DISALLOW_COPY_AND_ASSIGN(SandboxQuotaClientTest);
 };
 
 TEST_F(SandboxQuotaClientTest, NoFileSystemTest) {
   scoped_ptr<SandboxQuotaClient> quota_client(NewQuotaClient(false));
 
   EXPECT_EQ(0, GetOriginUsage(quota_client.get(), kDummyURL1, kTemporary));
 }
 
@@ skipping 209 matching lines @@
   // queried in incognito mode.
   EXPECT_EQ(0, GetOriginUsage(quota_client.get(), kDummyURL1, kTemporary));
   EXPECT_EQ(0, GetOriginUsage(quota_client.get(), kDummyURL1, kPersistent));
 
   std::set<GURL> origins = GetOriginsForType(quota_client.get(), kTemporary);
   EXPECT_EQ(0U, origins.size());
   origins = GetOriginsForHost(quota_client.get(), kTemporary, "www.dummy.org");
   EXPECT_EQ(0U, origins.size());
 }
 
+TEST_F(SandboxQuotaClientTest, DeleteOriginTest) {
+  scoped_ptr<SandboxQuotaClient> quota_client(NewQuotaClient(false));
+  const TestFile kFiles[] = {
+    {true, NULL,  0, "http://foo.com/",  kTemporary},
+    {false, "a",  1, "http://foo.com/",  kTemporary},
+    {true, NULL,  0, "https://foo.com/", kTemporary},
+    {false, "b",  2, "https://foo.com/", kTemporary},
+    {true, NULL,  0, "http://foo.com/",  kPersistent},
+    {false, "c",  4, "http://foo.com/",  kPersistent},
+    {true, NULL,  0, "http://bar.com/",  kTemporary},
+    {false, "d",  8, "http://bar.com/",  kTemporary},
+    {true, NULL,  0, "http://bar.com/",  kPersistent},
+    {false, "e", 16, "http://bar.com/",  kPersistent},
+    {true, NULL,  0, "https://bar.com/", kPersistent},
+    {false, "f", 32, "https://bar.com/", kPersistent},
+    {true, NULL,  0, "https://bar.com/", kTemporary},
+    {false, "g", 64, "https://bar.com/", kTemporary},
+  };
+  CreateFiles(kFiles, ARRAYSIZE_UNSAFE(kFiles));
+
+  DeleteOriginData(quota_client.get(), "http://foo.com/", kTemporary);
+  MessageLoop::current()->RunAllPending();
+  EXPECT_EQ(quota::kQuotaStatusOk, status());
+
+  DeleteOriginData(quota_client.get(), "http://bar.com/", kPersistent);
+  MessageLoop::current()->RunAllPending();
+  EXPECT_EQ(quota::kQuotaStatusOk, status());
+
+  DeleteOriginData(quota_client.get(), "http://buz.com/", kTemporary);
+  MessageLoop::current()->RunAllPending();
+  EXPECT_EQ(quota::kQuotaStatusOk, status());
+
+  EXPECT_EQ(0, GetOriginUsage(
+      quota_client.get(), "http://foo.com/", kTemporary));
+  EXPECT_EQ(0, GetOriginUsage(
+      quota_client.get(), "http://bar.com/", kPersistent));
+  EXPECT_EQ(0, GetOriginUsage(
+      quota_client.get(), "http://buz.com/", kTemporary));
+
+  EXPECT_EQ(2 + kUsageFileSize,
+            GetOriginUsage(quota_client.get(),
+                           "https://foo.com/",
+                           kTemporary));
+  EXPECT_EQ(4 + kUsageFileSize,
+            GetOriginUsage(quota_client.get(),
+                           "http://foo.com/",
+                           kPersistent));
+  EXPECT_EQ(8 + kUsageFileSize,
+            GetOriginUsage(quota_client.get(),
+                           "http://bar.com/",
+                           kTemporary));
+  EXPECT_EQ(32 + kUsageFileSize,
+            GetOriginUsage(quota_client.get(),
+                           "https://bar.com/",
+                           kPersistent));
+  EXPECT_EQ(64 + kUsageFileSize,
+            GetOriginUsage(quota_client.get(),
+                           "https://bar.com/",
+                           kTemporary));

[kinuko, 2011/05/16 06:18:53]

This looks good and no need to change this, but I felt this might be too much to
test DeleteOrigin... (like: tests for foo/bar look really similar to me)?

+}
+
 }  // namespace fileapi