Adding a test for the appcache removal functionality of BrowsingDataRemover.

BUG=NONE
TEST=BrowsingDataRemoverTest.RemoveAppCacheForever


Review URL: http://codereview.chromium.org/7324046

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

1 files changed, 147 insertions, 0 deletions

diff --git a/chrome/browser/browsing_data_remover_unittest.cc b/chrome/browser/browsing_data_remover_unittest.cc
index e55e87b..489efa7 100644
--- a/chrome/browser/browsing_data_remover_unittest.cc
+++ b/chrome/browser/browsing_data_remover_unittest.cc
@@ -4,11 +4,18 @@
 
 #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.h"
+#include "webkit/appcache/appcache_group.h"
+#include "webkit/appcache/appcache_storage.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_file_util.h"
@@ -25,6 +32,9 @@ 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() {}
@@ -156,6 +166,92 @@ class RemoveFileSystemTester : public BrowsingDataRemoverTester {
   DISALLOW_COPY_AND_ASSIGN(RemoveFileSystemTester);
 };
 
+// Helper class for injecting data into AppCacheStorage.
+class AppCacheInserter : public appcache::AppCacheStorage::Delegate {
+ public:
+  AppCacheInserter()
+      : group_id_(0),
+        appcache_id_(0),
+        response_id_(0) {}
+  virtual ~AppCacheInserter() {}
+
+  virtual void OnGroupAndNewestCacheStored(
+      appcache::AppCacheGroup* /*group*/,
+      appcache::AppCache* /*newest_cache*/,
+      bool success,
+      bool /*would_exceed_quota*/) {
+    ASSERT_TRUE(success);
+    MessageLoop::current()->Quit();
+  }
+
+  void AddGroupAndCache(ChromeAppCacheService* appcache_service,
+                        const GURL& manifest_url) {
+    appcache::AppCacheGroup* appcache_group =
+        new appcache::AppCacheGroup(appcache_service,
+                                    manifest_url,
+                                    ++group_id_);
+    appcache::AppCache* appcache = new appcache::AppCache(appcache_service,
+                                                          ++appcache_id_);
+    appcache::AppCacheEntry entry(appcache::AppCacheEntry::MANIFEST,
+                                  ++response_id_);
+    appcache->AddEntry(manifest_url, entry);
+    appcache->set_complete(true);
+    appcache_group->AddCache(appcache);
+    appcache_service->storage()->StoreGroupAndNewestCache(appcache_group,
+                                                          appcache,
+                                                          this);
+    // OnGroupAndNewestCacheStored will quit the message loop.
+    MessageLoop::current()->Run();
+  }
+
+ private:
+  int group_id_;
+  int appcache_id_;
+  int response_id_;
+
+  DISALLOW_COPY_AND_ASSIGN(AppCacheInserter);
+};
+
+// Helper class for reading appcaches.
+class AppCacheReader {
+ public:
+  explicit AppCacheReader(ChromeAppCacheService* appcache_service)
+    : appcache_service_(appcache_service),
+      ALLOW_THIS_IN_INITIALIZER_LIST(appcache_got_info_callback_(
+          this, &AppCacheReader::OnGotAppCacheInfo)) {
+  }
+
+  std::set<GURL>* ReadAppCaches() {
+    appcache_info_ = new appcache::AppCacheInfoCollection;
+    appcache_service_->GetAllAppCacheInfo(
+        appcache_info_, &appcache_got_info_callback_);
+
+    MessageLoop::current()->Run();
+    return &origins_;
+  }
+
+ private:
+  void OnGotAppCacheInfo(int rv) {
+    typedef std::map<GURL, appcache::AppCacheInfoVector> InfoByOrigin;
+
+    origins_.clear();
+    for (InfoByOrigin::const_iterator origin =
+             appcache_info_->infos_by_origin.begin();
+         origin != appcache_info_->infos_by_origin.end(); ++origin) {
+      origins_.insert(origin->first);
+    }
+    MessageLoop::current()->Quit();
+  }
+
+  scoped_refptr<ChromeAppCacheService> appcache_service_;
+  net::CompletionCallbackImpl<AppCacheReader>
+      appcache_got_info_callback_;
+  scoped_refptr<appcache::AppCacheInfoCollection> appcache_info_;
+  std::set<GURL> origins_;
+
+  DISALLOW_COPY_AND_ASSIGN(AppCacheReader);
+};
+
 class BrowsingDataRemoverTest : public testing::Test {
  public:
   BrowsingDataRemoverTest()
@@ -264,4 +360,55 @@ TEST_F(BrowsingDataRemoverTest, RemoveFileSystemsForever) {
       fileapi::kFileSystemTypeTemporary));
 }
 
+TEST_F(BrowsingDataRemoverTest, RemoveAppCacheForever) {
+  // Set up ChromeAppCacheService.
+  scoped_refptr<ChromeAppCacheService> appcache_service =
+      new ChromeAppCacheService(NULL);
+  const content::ResourceContext* resource_context = NULL;
+  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,
+                        false));
+  MessageLoop::current()->RunAllPending();
+  TestingProfile* profile = GetProfile();
+  profile->SetAppCacheService(appcache_service);
+  profile->SetExtensionSpecialStoragePolicy(mock_policy);
+
+  // Add data into the AppCacheStorage.
+  AppCacheInserter appcache_inserter;
+  appcache_inserter.AddGroupAndCache(appcache_service, kNormalManifest);
+  appcache_inserter.AddGroupAndCache(appcache_service, kProtectedManifest);
+
+  // Verify that adding the data succeeded.
+  AppCacheReader reader(appcache_service);
+  std::set<GURL>* origins = reader.ReadAppCaches();
+  EXPECT_EQ(2UL, origins->size());
+  EXPECT_TRUE(origins->find(kProtectedManifest.GetOrigin()) != origins->end());
+  EXPECT_TRUE(origins->find(kNormalManifest.GetOrigin()) != origins->end());
+
+  // 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.
+  origins = reader.ReadAppCaches();
+  EXPECT_EQ(1UL, origins->size());
+  EXPECT_TRUE(origins->find(kProtectedManifest.GetOrigin()) != origins->end());
+}
+
 }  // namespace