| // 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.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" |
| #include "webkit/fileapi/file_system_path_manager.h" |
| #include "webkit/fileapi/sandbox_mount_point_provider.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); |
| }; |
| |
| 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) { |
| history_service_->QueryURL( |
| url, |
| true, |
| &consumer_, |
| NewCallback(this, &RemoveHistoryTester::SaveResultAndQuit)); |
| BlockUntilNotified(); |
| return query_url_success_; |
| } |
| |
| void AddHistory(const GURL& url, base::Time time) { |
| history_service_->AddPage(url, time, NULL, 0, GURL(), PageTransition::LINK, |
| history::RedirectList(), history::SOURCE_BROWSED, false); |
| } |
| |
| private: |
| // Callback for HistoryService::QueryURL. |
| void SaveResultAndQuit(HistoryService::Handle, |
| bool success, |
| const history::URLRow*, |
| history::VisitVector*) { |
| query_url_success_ = success; |
| Notify(); |
| } |
| |
| |
| // 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 { |
| public: |
| explicit RemoveFileSystemTester() {} |
| |
| void FindFileSystemPathCallback(bool success, |
| const FilePath& path, |
| const std::string& name) { |
| found_file_system_ = success; |
| Notify(); |
| } |
| |
| 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)); |
| } |
| |
| private: |
| fileapi::SandboxMountPointProvider* sandbox_; |
| bool found_file_system_; |
| |
| 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() |
| : 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()) { |
| } |
| |
| virtual ~BrowsingDataRemoverTest() { |
| } |
| |
| void TearDown() { |
| // TestingProfile contains a WebKitContext. WebKitContext's destructor |
| // posts a message to the WEBKIT thread to delete some of its member |
| // variables. We need to ensure that the profile is destroyed, and that |
| // the message loop is cleared out, before destroying the threads and loop. |
| // Otherwise we leak memory. |
| profile_.reset(); |
| message_loop_.RunAllPending(); |
| } |
| |
| void BlockUntilBrowsingDataRemoved(BrowsingDataRemover::TimePeriod period, |
| base::Time delete_end, |
| int remove_mask, |
| BrowsingDataRemoverTester* tester) { |
| BrowsingDataRemover* remover = new BrowsingDataRemover(profile_.get(), |
| period, delete_end); |
| remover->AddObserver(tester); |
| |
| // BrowsingDataRemover deletes itself when it completes. |
| remover->Remove(remove_mask); |
| tester->BlockUntilNotified(); |
| } |
| |
| TestingProfile* GetProfile() { |
| return profile_.get(); |
| } |
| |
| 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); |
| }; |
| |
| 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()); |
| |
| EXPECT_FALSE(tester->HistoryContainsURL(kOrigin1)); |
| } |
| |
| TEST_F(BrowsingDataRemoverTest, RemoveHistoryForLastHour) { |
| scoped_ptr<RemoveHistoryTester> tester( |
| new RemoveHistoryTester(GetProfile())); |
| |
| base::Time two_hours_ago = base::Time::Now() - base::TimeDelta::FromHours(2); |
| |
| tester->AddHistory(kOrigin1, base::Time::Now()); |
| tester->AddHistory(kOrigin2, two_hours_ago); |
| 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()); |
| |
| 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)); |
| } |
| |
| 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 |