Time-based removal of temporary file systems via BrowsingDataRemover

chrome/browser/browsing_data_remover_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 "chrome/browser/browsing_data_remover.h"
 
 #include <set>
 
 #include "base/message_loop.h"
 #include "base/platform_file.h"
 #include "chrome/browser/extensions/mock_extension_special_storage_policy.h"
 #include "chrome/browser/history/history.h"
 #include "chrome/test/testing_profile.h"
-#include "content/browser/appcache/chrome_appcache_service.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "webkit/appcache/appcache_test_helper.h"
 #include "webkit/fileapi/file_system_context.h"
+#include "webkit/fileapi/file_system_file_util.h"
 #include "webkit/fileapi/file_system_operation_context.h"
-#include "webkit/fileapi/file_system_file_util.h"
 #include "webkit/fileapi/file_system_path_manager.h"
 #include "webkit/fileapi/sandbox_mount_point_provider.h"
+#include "webkit/quota/mock_quota_manager.h"
+#include "webkit/quota/quota_manager.h"
+#include "webkit/quota/quota_types.h"
 
 namespace {
 
 const char kTestkOrigin1[] = "http://host1:1/";
 const char kTestkOrigin2[] = "http://host2:1/";
 const char kTestkOrigin3[] = "http://host3:1/";
 
 const GURL kOrigin1(kTestkOrigin1);
 const GURL kOrigin2(kTestkOrigin2);
 const GURL kOrigin3(kTestkOrigin3);
 
-const GURL kProtectedManifest("http://www.protected.com/cache.manifest");
-const GURL kNormalManifest("http://www.normal.com/cache.manifest");
-
 class BrowsingDataRemoverTester : public BrowsingDataRemover::Observer {
  public:
   BrowsingDataRemoverTester() {}
   virtual ~BrowsingDataRemoverTester() {}
 
   void BlockUntilNotified() {
     MessageLoop::current()->Run();
   }
 
  protected:
   // BrowsingDataRemover::Observer implementation.
   virtual void OnBrowsingDataRemoverDone() {
     Notify();
   }
 
   void Notify() {
     MessageLoop::current()->Quit();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BrowsingDataRemoverTester);
 };
 
+// Testers -------------------------------------------------------------------
+
 class RemoveHistoryTester : public BrowsingDataRemoverTester {
  public:
   explicit RemoveHistoryTester(TestingProfile* profile)
       : query_url_success_(false) {
     profile->CreateHistoryService(true, false);
     history_service_ = profile->GetHistoryService(Profile::EXPLICIT_ACCESS);
   }
 
   // Returns true, if the given URL exists in the history service.
   bool HistoryContainsURL(const GURL& url) {
@@ skipping 25 matching lines @@
   // For History requests.
   CancelableRequestConsumer consumer_;
   bool query_url_success_;
 
   // TestingProfile owns the history service; we shouldn't delete it.
   HistoryService* history_service_;
 
   DISALLOW_COPY_AND_ASSIGN(RemoveHistoryTester);
 };
 
-class RemoveFileSystemTester : public BrowsingDataRemoverTester {
+class RemoveQuotaManagedDataTester : public BrowsingDataRemoverTester {
  public:
-  explicit RemoveFileSystemTester() {}
+  RemoveQuotaManagedDataTester() {}
+  virtual ~RemoveQuotaManagedDataTester() {}
 
-  void FindFileSystemPathCallback(bool success,
-                                  const FilePath& path,
-                                  const std::string& name) {
-    found_file_system_ = success;
-    Notify();
-  }
+  void PopulateTestQuotaManagedData(quota::MockQuotaManager* manager) {
+    // Set up kOrigin1 with a temporary quota, kOrigin2 with a persistent
+    // quota, and kOrigin3 with both. kOrigin1 is modified now, kOrigin2
+    // is modified at the beginning of time, and kOrigin3 is modified one day
+    // ago.
+    manager->AddOrigin(kOrigin1, quota::kStorageTypeTemporary,
+        base::Time::Now());
+    manager->AddOrigin(kOrigin2, quota::kStorageTypePersistent,
+        base::Time());
+    manager->AddOrigin(kOrigin3, quota::kStorageTypeTemporary,
+        base::Time::Now() - base::TimeDelta::FromDays(1));
+    manager->AddOrigin(kOrigin3, quota::kStorageTypePersistent,
+        base::Time::Now() - base::TimeDelta::FromDays(1));
 
-  bool FileSystemContainsOriginAndType(const GURL& origin,
-                                       fileapi::FileSystemType type) {
-    sandbox_->ValidateFileSystemRootAndGetURL(
-        origin, type, false, NewCallback(this,
-            &RemoveFileSystemTester::FindFileSystemPathCallback));
-    BlockUntilNotified();
-    return found_file_system_;
-  }
-
-  virtual void PopulateTestFileSystemData(TestingProfile* profile) {
-    // Set up kOrigin1 with a temporary file system, kOrigin2 with a persistent
-    // file system, and kOrigin3 with both.
-    sandbox_ = profile->GetFileSystemContext()->path_manager()->
-        sandbox_provider();
-
-    CreateDirectoryForOriginAndType(kOrigin1,
-        fileapi::kFileSystemTypeTemporary);
-    CreateDirectoryForOriginAndType(kOrigin2,
-        fileapi::kFileSystemTypePersistent);
-    CreateDirectoryForOriginAndType(kOrigin3,
-        fileapi::kFileSystemTypeTemporary);
-    CreateDirectoryForOriginAndType(kOrigin3,
-        fileapi::kFileSystemTypePersistent);
-
-    EXPECT_FALSE(FileSystemContainsOriginAndType(kOrigin1,
-        fileapi::kFileSystemTypePersistent));
-    EXPECT_TRUE(FileSystemContainsOriginAndType(kOrigin1,
-        fileapi::kFileSystemTypeTemporary));
-    EXPECT_TRUE(FileSystemContainsOriginAndType(kOrigin2,
-        fileapi::kFileSystemTypePersistent));
-    EXPECT_FALSE(FileSystemContainsOriginAndType(kOrigin2,
-        fileapi::kFileSystemTypeTemporary));
-    EXPECT_TRUE(FileSystemContainsOriginAndType(kOrigin3,
-        fileapi::kFileSystemTypePersistent));
-    EXPECT_TRUE(FileSystemContainsOriginAndType(kOrigin3,
-        fileapi::kFileSystemTypeTemporary));
-  }
-
-  void CreateDirectoryForOriginAndType(const GURL& origin,
-                                       fileapi::FileSystemType type) {
-    FilePath target = sandbox_->ValidateFileSystemRootAndGetPathOnFileThread(
-        origin, type, FilePath(), true);
-    EXPECT_TRUE(file_util::DirectoryExists(target));
+    EXPECT_TRUE(manager->OriginHasData(kOrigin1,
+        quota::kStorageTypeTemporary));
+    EXPECT_FALSE(manager->OriginHasData(kOrigin2,
+        quota::kStorageTypeTemporary));
+    EXPECT_TRUE(manager->OriginHasData(kOrigin3,
+        quota::kStorageTypeTemporary));
+    EXPECT_FALSE(manager->OriginHasData(kOrigin1,
+        quota::kStorageTypePersistent));
+    EXPECT_TRUE(manager->OriginHasData(kOrigin2,
+        quota::kStorageTypePersistent));
+    EXPECT_TRUE(manager->OriginHasData(kOrigin3,
+        quota::kStorageTypePersistent));
   }
 
  private:
-  fileapi::SandboxMountPointProvider* sandbox_;
-  bool found_file_system_;
+  DISALLOW_COPY_AND_ASSIGN(RemoveQuotaManagedDataTester);
+};
 
-  DISALLOW_COPY_AND_ASSIGN(RemoveFileSystemTester);
-};
+// Test Class ----------------------------------------------------------------
 
 class BrowsingDataRemoverTest : public testing::Test {
  public:
   BrowsingDataRemoverTest()
       : ui_thread_(BrowserThread::UI, &message_loop_),
         db_thread_(BrowserThread::DB, &message_loop_),
         webkit_thread_(BrowserThread::WEBKIT, &message_loop_),
         file_thread_(BrowserThread::FILE, &message_loop_),
         io_thread_(BrowserThread::IO, &message_loop_),
         profile_(new TestingProfile()) {
@@ skipping 22 matching lines @@
 
     // BrowsingDataRemover deletes itself when it completes.
     remover->Remove(remove_mask);
     tester->BlockUntilNotified();
   }
 
   TestingProfile* GetProfile() {
     return profile_.get();
   }
 
+  quota::MockQuotaManager* GetMockManager() {
+    return (quota::MockQuotaManager*) profile_->GetQuotaManager();
+  }
+
  private:
   // message_loop_, as well as all the threads associated with it must be
   // defined before profile_ to prevent explosions. Oh how I love C++.
   MessageLoopForUI message_loop_;
   BrowserThread ui_thread_;
   BrowserThread db_thread_;
   BrowserThread webkit_thread_;
   BrowserThread file_thread_;
   BrowserThread io_thread_;
   scoped_ptr<TestingProfile> profile_;
 
   DISALLOW_COPY_AND_ASSIGN(BrowsingDataRemoverTest);
 };
 
+// Tests ---------------------------------------------------------------------
+
 TEST_F(BrowsingDataRemoverTest, RemoveHistoryForever) {
   scoped_ptr<RemoveHistoryTester> tester(
       new RemoveHistoryTester(GetProfile()));
 
   tester->AddHistory(kOrigin1, base::Time::Now());
   ASSERT_TRUE(tester->HistoryContainsURL(kOrigin1));
 
   BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
       base::Time::Now(), BrowsingDataRemover::REMOVE_HISTORY, tester.get());
 
@@ skipping 11 matching lines @@
   ASSERT_TRUE(tester->HistoryContainsURL(kOrigin1));
   ASSERT_TRUE(tester->HistoryContainsURL(kOrigin2));
 
   BlockUntilBrowsingDataRemoved(BrowsingDataRemover::LAST_HOUR,
       base::Time::Now(), BrowsingDataRemover::REMOVE_HISTORY, tester.get());
 
   EXPECT_FALSE(tester->HistoryContainsURL(kOrigin1));
   EXPECT_TRUE(tester->HistoryContainsURL(kOrigin2));
 }
 
-TEST_F(BrowsingDataRemoverTest, RemoveFileSystemsForever) {
-  scoped_ptr<RemoveFileSystemTester> tester(new RemoveFileSystemTester());
-
-  tester->PopulateTestFileSystemData(GetProfile());
+TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedDataForever) {
+  scoped_ptr<RemoveQuotaManagedDataTester> tester(
+      new RemoveQuotaManagedDataTester());
+  tester->PopulateTestQuotaManagedData(GetMockManager());
 
   BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
       base::Time::Now(), BrowsingDataRemover::REMOVE_COOKIES, tester.get());
 
-  EXPECT_FALSE(tester->FileSystemContainsOriginAndType(kOrigin1,
-      fileapi::kFileSystemTypePersistent));
-  EXPECT_FALSE(tester->FileSystemContainsOriginAndType(kOrigin1,
-      fileapi::kFileSystemTypeTemporary));
-  EXPECT_FALSE(tester->FileSystemContainsOriginAndType(kOrigin2,
-      fileapi::kFileSystemTypePersistent));
-  EXPECT_FALSE(tester->FileSystemContainsOriginAndType(kOrigin2,
-      fileapi::kFileSystemTypeTemporary));
-  EXPECT_FALSE(tester->FileSystemContainsOriginAndType(kOrigin3,
-      fileapi::kFileSystemTypePersistent));
-  EXPECT_FALSE(tester->FileSystemContainsOriginAndType(kOrigin3,
-      fileapi::kFileSystemTypeTemporary));
+  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1,
+      quota::kStorageTypeTemporary));
+  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2,
+      quota::kStorageTypeTemporary));
+  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3,
+      quota::kStorageTypeTemporary));
+  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1,
+      quota::kStorageTypePersistent));
+  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2,
+      quota::kStorageTypePersistent));
+  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3,
+      quota::kStorageTypePersistent));
 }
 
-TEST_F(BrowsingDataRemoverTest, RemoveAppCacheForever) {
-  // Set up ChromeAppCacheService.
-  scoped_refptr<ChromeAppCacheService> appcache_service =
-      new ChromeAppCacheService(NULL);
-  const content::ResourceContext* resource_context = NULL;
+TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedDataForLastHour) {
+  scoped_ptr<RemoveQuotaManagedDataTester> tester(
+      new RemoveQuotaManagedDataTester());
+  tester->PopulateTestQuotaManagedData(GetMockManager());
+
+  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::LAST_HOUR,
+      base::Time::Now(), BrowsingDataRemover::REMOVE_COOKIES, tester.get());
+
+  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1,
+      quota::kStorageTypeTemporary));
+  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2,
+      quota::kStorageTypeTemporary));
+  EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin3,
+      quota::kStorageTypeTemporary));
+  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1,
+      quota::kStorageTypePersistent));
+  EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin2,
+      quota::kStorageTypePersistent));
+  EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin3,
+      quota::kStorageTypePersistent));
+}
+
+TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedDataForLastWeek) {
+  scoped_ptr<RemoveQuotaManagedDataTester> tester(
+      new RemoveQuotaManagedDataTester());
+  tester->PopulateTestQuotaManagedData(GetMockManager());
+
+  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::LAST_WEEK,
+      base::Time::Now(), BrowsingDataRemover::REMOVE_COOKIES, tester.get());
+
+  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1,
+      quota::kStorageTypeTemporary));
+  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2,
+      quota::kStorageTypeTemporary));
+  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3,
+      quota::kStorageTypeTemporary));
+  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1,
+      quota::kStorageTypePersistent));
+  EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin2,
+      quota::kStorageTypePersistent));
+  EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin3,
+      quota::kStorageTypePersistent));
+}
+
+TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedUnprotectedOrigins) {
+  // Protect kOrigin1.
   scoped_refptr<MockExtensionSpecialStoragePolicy> mock_policy =
-      new MockExtensionSpecialStoragePolicy;
-  mock_policy->AddProtected(kProtectedManifest.GetOrigin());
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      NewRunnableMethod(appcache_service.get(),
-                        &ChromeAppCacheService::InitializeOnIOThread,
-                        FilePath(),
-                        resource_context,
-                        mock_policy));
-  MessageLoop::current()->RunAllPending();
-  TestingProfile* profile = GetProfile();
-  profile->SetAppCacheService(appcache_service);
-  profile->SetExtensionSpecialStoragePolicy(mock_policy);
+          new MockExtensionSpecialStoragePolicy;
+  mock_policy->AddProtected(kOrigin1.GetOrigin());
+  GetProfile()->SetExtensionSpecialStoragePolicy(mock_policy);
 
-  // Add data into the AppCacheStorage.
-  appcache::AppCacheTestHelper appcache_helper;
-  appcache_helper.AddGroupAndCache(appcache_service, kNormalManifest);
-  appcache_helper.AddGroupAndCache(appcache_service, kProtectedManifest);
+  scoped_ptr<RemoveQuotaManagedDataTester> tester(
+      new RemoveQuotaManagedDataTester());
+  tester->PopulateTestQuotaManagedData(GetMockManager());
 
-  // Verify that adding the data succeeded.
-  std::set<GURL> origins;
-  appcache_helper.GetOriginsWithCaches(appcache_service, &origins);
-  EXPECT_EQ(2UL, origins.size());
-  EXPECT_TRUE(origins.find(kProtectedManifest.GetOrigin()) != origins.end());
-  EXPECT_TRUE(origins.find(kNormalManifest.GetOrigin()) != origins.end());
+  BlockUntilBrowsingDataRemoved(BrowsingDataRemover::EVERYTHING,
+      base::Time::Now(), BrowsingDataRemover::REMOVE_COOKIES, tester.get());
 
-  // Set up the object to be tested.
-  scoped_ptr<BrowsingDataRemoverTester> tester(new BrowsingDataRemoverTester());
-  BrowsingDataRemover* remover = new BrowsingDataRemover(
-      profile, BrowsingDataRemover::EVERYTHING, base::Time::Now());
-  remover->AddObserver(tester.get());
-
-  // Remove the appcaches and wait for it to complete. BrowsingDataRemover
-  // deletes itself when it completes.
-  remover->Remove(BrowsingDataRemover::REMOVE_COOKIES);
-  tester->BlockUntilNotified();
-
-  // Results: appcaches for the normal origin got deleted, appcaches for the
-  // protected origin didn't.
-  appcache_helper.GetOriginsWithCaches(appcache_service, &origins);
-  EXPECT_EQ(1UL, origins.size());
-  EXPECT_TRUE(origins.find(kProtectedManifest.GetOrigin()) != origins.end());
+  EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin1,
+      quota::kStorageTypeTemporary));
+  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2,
+      quota::kStorageTypeTemporary));
+  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3,
+      quota::kStorageTypeTemporary));
+  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1,
+      quota::kStorageTypePersistent));
+  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2,
+      quota::kStorageTypePersistent));
+  EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3,
+      quota::kStorageTypePersistent));
 }
 
 }  // namespace