1bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner// Copyright 2013 The Chromium Authors. All rights reserved. 2bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner// Use of this source code is governed by a BSD-style license that can be 3bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner// found in the LICENSE file. 4bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner 5fc001bbfc360ab828e5a4b0cbe4bb7db87361b85Chris Lattner#include "base/files/file_util.h" 6fc001bbfc360ab828e5a4b0cbe4bb7db87361b85Chris Lattner#include "base/message_loop/message_loop_proxy.h" 7bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner#include "base/run_loop.h" 8bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner#include "base/threading/thread.h" 9bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner#include "content/browser/browser_thread_impl.h" 10bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner#include "content/browser/gpu/shader_disk_cache.h" 11bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner#include "content/browser/quota/mock_quota_manager.h" 12bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner#include "content/browser/storage_partition_impl.h" 13bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner#include "content/public/browser/local_storage_usage_info.h" 14bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner#include "content/public/browser/storage_partition.h" 15bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner#include "content/public/test/mock_special_storage_policy.h" 16bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner#include "content/public/test/test_browser_context.h" 17bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner#include "content/public/test/test_browser_thread.h" 18bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner#include "content/public/test/test_browser_thread_bundle.h" 19bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner#include "net/base/test_completion_callback.h" 20bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner#include "net/cookies/cookie_monster.h" 21bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner#include "net/url_request/url_request_context.h" 22bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner#include "net/url_request/url_request_context_getter.h" 23bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner#include "storage/browser/quota/quota_manager.h" 24bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner#include "testing/gtest/include/gtest/gtest.h" 25bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner 26bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattnernamespace content { 27bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattnernamespace { 28bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner 29bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattnerconst int kDefaultClientId = 42; 30bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattnerconst char kCacheKey[] = "key"; 31bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattnerconst char kCacheValue[] = "cached value"; 32bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner 33bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattnerconst char kTestOrigin1[] = "http://host1:1/"; 34bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattnerconst char kTestOrigin2[] = "http://host2:1/"; 35bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattnerconst char kTestOrigin3[] = "http://host3:1/"; 36bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattnerconst char kTestOriginDevTools[] = "chrome-devtools://abcdefghijklmnopqrstuvw/"; 37bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner 38bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattnerconst GURL kOrigin1(kTestOrigin1); 39bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattnerconst GURL kOrigin2(kTestOrigin2); 40bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattnerconst GURL kOrigin3(kTestOrigin3); 41bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattnerconst GURL kOriginDevTools(kTestOriginDevTools); 42bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner 43bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattnerconst base::FilePath::CharType kDomStorageOrigin1[] = 44bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner FILE_PATH_LITERAL("http_host1_1.localstorage"); 45bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner 46bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattnerconst base::FilePath::CharType kDomStorageOrigin2[] = 47bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner FILE_PATH_LITERAL("http_host2_1.localstorage"); 48bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner 49bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattnerconst base::FilePath::CharType kDomStorageOrigin3[] = 50bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner FILE_PATH_LITERAL("http_host3_1.localstorage"); 51bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner 52bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattnerconst storage::StorageType kTemporary = storage::kStorageTypeTemporary; 53bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattnerconst storage::StorageType kPersistent = storage::kStorageTypePersistent; 54bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner 55bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattnerconst storage::QuotaClient::ID kClientFile = storage::QuotaClient::kFileSystem; 56bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner 57bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattnerconst uint32 kAllQuotaRemoveMask = 58bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner StoragePartition::REMOVE_DATA_MASK_APPCACHE | 59bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS | 60bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner StoragePartition::REMOVE_DATA_MASK_INDEXEDDB | 61bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner StoragePartition::REMOVE_DATA_MASK_WEBSQL; 62bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner 63bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattnerclass AwaitCompletionHelper { 64bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner public: 65bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner AwaitCompletionHelper() : start_(false), already_quit_(false) {} 66bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner virtual ~AwaitCompletionHelper() {} 67bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner 68bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner void BlockUntilNotified() { 69bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner if (!already_quit_) { 70bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner DCHECK(!start_); 71bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner start_ = true; 72bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner base::MessageLoop::current()->Run(); 73bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner } else { 74bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner DCHECK(!start_); 75bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner already_quit_ = false; 76bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner } 77bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner } 78bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner 79bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner void Notify() { 80bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner if (start_) { 81bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner DCHECK(!already_quit_); 82bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner base::MessageLoop::current()->Quit(); 83bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner start_ = false; 84bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner } else { 85bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner DCHECK(!already_quit_); 86bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner already_quit_ = true; 87bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner } 88bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner } 89bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner 90bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner private: 91bef8e0b0a7afe602ddf09165ff4dbb8fa5f696a9Chris Lattner // Helps prevent from running message_loop, if the callback invoked 92 // immediately. 93 bool start_; 94 bool already_quit_; 95 96 DISALLOW_COPY_AND_ASSIGN(AwaitCompletionHelper); 97}; 98 99class RemoveCookieTester { 100 public: 101 explicit RemoveCookieTester(TestBrowserContext* context) 102 : get_cookie_success_(false), monster_(NULL) { 103 SetMonster(context->GetRequestContext()->GetURLRequestContext()-> 104 cookie_store()->GetCookieMonster()); 105 } 106 107 // Returns true, if the given cookie exists in the cookie store. 108 bool ContainsCookie() { 109 get_cookie_success_ = false; 110 monster_->GetCookiesWithOptionsAsync( 111 kOrigin1, net::CookieOptions(), 112 base::Bind(&RemoveCookieTester::GetCookieCallback, 113 base::Unretained(this))); 114 await_completion_.BlockUntilNotified(); 115 return get_cookie_success_; 116 } 117 118 void AddCookie() { 119 monster_->SetCookieWithOptionsAsync( 120 kOrigin1, "A=1", net::CookieOptions(), 121 base::Bind(&RemoveCookieTester::SetCookieCallback, 122 base::Unretained(this))); 123 await_completion_.BlockUntilNotified(); 124 } 125 126 protected: 127 void SetMonster(net::CookieStore* monster) { 128 monster_ = monster; 129 } 130 131 private: 132 void GetCookieCallback(const std::string& cookies) { 133 if (cookies == "A=1") { 134 get_cookie_success_ = true; 135 } else { 136 EXPECT_EQ("", cookies); 137 get_cookie_success_ = false; 138 } 139 await_completion_.Notify(); 140 } 141 142 void SetCookieCallback(bool result) { 143 ASSERT_TRUE(result); 144 await_completion_.Notify(); 145 } 146 147 bool get_cookie_success_; 148 AwaitCompletionHelper await_completion_; 149 net::CookieStore* monster_; 150 151 DISALLOW_COPY_AND_ASSIGN(RemoveCookieTester); 152}; 153 154class RemoveLocalStorageTester { 155 public: 156 explicit RemoveLocalStorageTester(TestBrowserContext* profile) 157 : profile_(profile), dom_storage_context_(NULL) { 158 dom_storage_context_ = 159 content::BrowserContext::GetDefaultStoragePartition(profile)-> 160 GetDOMStorageContext(); 161 } 162 163 // Returns true, if the given origin URL exists. 164 bool DOMStorageExistsForOrigin(const GURL& origin) { 165 GetLocalStorageUsage(); 166 await_completion_.BlockUntilNotified(); 167 for (size_t i = 0; i < infos_.size(); ++i) { 168 if (origin == infos_[i].origin) 169 return true; 170 } 171 return false; 172 } 173 174 void AddDOMStorageTestData() { 175 // Note: This test depends on details of how the dom_storage library 176 // stores data in the host file system. 177 base::FilePath storage_path = 178 profile_->GetPath().AppendASCII("Local Storage"); 179 base::CreateDirectory(storage_path); 180 181 // Write some files. 182 base::WriteFile(storage_path.Append(kDomStorageOrigin1), NULL, 0); 183 base::WriteFile(storage_path.Append(kDomStorageOrigin2), NULL, 0); 184 base::WriteFile(storage_path.Append(kDomStorageOrigin3), NULL, 0); 185 186 // Tweak their dates. 187 base::Time now = base::Time::Now(); 188 base::TouchFile(storage_path.Append(kDomStorageOrigin1), now, now); 189 190 base::Time one_day_ago = now - base::TimeDelta::FromDays(1); 191 base::TouchFile(storage_path.Append(kDomStorageOrigin2), 192 one_day_ago, one_day_ago); 193 194 base::Time sixty_days_ago = now - base::TimeDelta::FromDays(60); 195 base::TouchFile(storage_path.Append(kDomStorageOrigin3), 196 sixty_days_ago, sixty_days_ago); 197 } 198 199 private: 200 void GetLocalStorageUsage() { 201 dom_storage_context_->GetLocalStorageUsage( 202 base::Bind(&RemoveLocalStorageTester::OnGotLocalStorageUsage, 203 base::Unretained(this))); 204 } 205 void OnGotLocalStorageUsage( 206 const std::vector<content::LocalStorageUsageInfo>& infos) { 207 infos_ = infos; 208 await_completion_.Notify(); 209 } 210 211 // We don't own these pointers. 212 TestBrowserContext* profile_; 213 content::DOMStorageContext* dom_storage_context_; 214 215 std::vector<content::LocalStorageUsageInfo> infos_; 216 217 AwaitCompletionHelper await_completion_; 218 219 DISALLOW_COPY_AND_ASSIGN(RemoveLocalStorageTester); 220}; 221 222bool IsWebSafeSchemeForTest(const std::string& scheme) { 223 return scheme == "http"; 224} 225 226bool DoesOriginMatchForUnprotectedWeb( 227 const GURL& origin, 228 storage::SpecialStoragePolicy* special_storage_policy) { 229 if (IsWebSafeSchemeForTest(origin.scheme())) 230 return !special_storage_policy->IsStorageProtected(origin.GetOrigin()); 231 232 return false; 233} 234 235bool DoesOriginMatchForBothProtectedAndUnprotectedWeb( 236 const GURL& origin, 237 storage::SpecialStoragePolicy* special_storage_policy) { 238 return true; 239} 240 241bool DoesOriginMatchUnprotected( 242 const GURL& origin, 243 storage::SpecialStoragePolicy* special_storage_policy) { 244 return origin.GetOrigin().scheme() != kOriginDevTools.scheme(); 245} 246 247void ClearQuotaData(content::StoragePartition* partition, 248 base::RunLoop* loop_to_quit) { 249 partition->ClearData(kAllQuotaRemoveMask, 250 StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL, GURL(), 251 StoragePartition::OriginMatcherFunction(), base::Time(), 252 base::Time::Max(), loop_to_quit->QuitClosure()); 253} 254 255void ClearQuotaDataWithOriginMatcher( 256 content::StoragePartition* partition, 257 const GURL& remove_origin, 258 const StoragePartition::OriginMatcherFunction& origin_matcher, 259 const base::Time delete_begin, 260 base::RunLoop* loop_to_quit) { 261 partition->ClearData(kAllQuotaRemoveMask, 262 StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL, 263 remove_origin, origin_matcher, delete_begin, 264 base::Time::Max(), loop_to_quit->QuitClosure()); 265} 266 267void ClearQuotaDataForOrigin( 268 content::StoragePartition* partition, 269 const GURL& remove_origin, 270 const base::Time delete_begin, 271 base::RunLoop* loop_to_quit) { 272 ClearQuotaDataWithOriginMatcher( 273 partition, remove_origin, 274 StoragePartition::OriginMatcherFunction(), delete_begin, 275 loop_to_quit); 276} 277 278void ClearQuotaDataForNonPersistent( 279 content::StoragePartition* partition, 280 const base::Time delete_begin, 281 base::RunLoop* loop_to_quit) { 282 partition->ClearData( 283 kAllQuotaRemoveMask, 284 ~StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT, 285 GURL(), StoragePartition::OriginMatcherFunction(), delete_begin, 286 base::Time::Max(), loop_to_quit->QuitClosure()); 287} 288 289void ClearCookies(content::StoragePartition* partition, 290 const base::Time delete_begin, 291 const base::Time delete_end, 292 base::RunLoop* run_loop) { 293 partition->ClearData( 294 StoragePartition::REMOVE_DATA_MASK_COOKIES, 295 StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL, 296 GURL(), StoragePartition::OriginMatcherFunction(), 297 delete_begin, delete_end, run_loop->QuitClosure()); 298} 299 300void ClearStuff(uint32 remove_mask, 301 content::StoragePartition* partition, 302 const base::Time delete_begin, 303 const base::Time delete_end, 304 const StoragePartition::OriginMatcherFunction& origin_matcher, 305 base::RunLoop* run_loop) { 306 partition->ClearData( 307 remove_mask, StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL, 308 GURL(), origin_matcher, delete_begin, delete_end, 309 run_loop->QuitClosure()); 310} 311 312void ClearData(content::StoragePartition* partition, 313 base::RunLoop* run_loop) { 314 base::Time time; 315 partition->ClearData( 316 StoragePartition::REMOVE_DATA_MASK_SHADER_CACHE, 317 StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL, 318 GURL(), StoragePartition::OriginMatcherFunction(), 319 time, time, run_loop->QuitClosure()); 320} 321 322} // namespace 323 324class StoragePartitionImplTest : public testing::Test { 325 public: 326 StoragePartitionImplTest() 327 : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP), 328 browser_context_(new TestBrowserContext()) { 329 } 330 331 MockQuotaManager* GetMockManager() { 332 if (!quota_manager_.get()) { 333 quota_manager_ = new MockQuotaManager( 334 browser_context_->IsOffTheRecord(), 335 browser_context_->GetPath(), 336 BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO).get(), 337 BrowserThread::GetMessageLoopProxyForThread(BrowserThread::DB).get(), 338 browser_context_->GetSpecialStoragePolicy()); 339 } 340 return quota_manager_.get(); 341 } 342 343 TestBrowserContext* browser_context() { 344 return browser_context_.get(); 345 } 346 347 private: 348 content::TestBrowserThreadBundle thread_bundle_; 349 scoped_ptr<TestBrowserContext> browser_context_; 350 scoped_refptr<MockQuotaManager> quota_manager_; 351 352 DISALLOW_COPY_AND_ASSIGN(StoragePartitionImplTest); 353}; 354 355class StoragePartitionShaderClearTest : public testing::Test { 356 public: 357 StoragePartitionShaderClearTest() 358 : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP), 359 browser_context_(new TestBrowserContext()) { 360 ShaderCacheFactory::GetInstance()->SetCacheInfo( 361 kDefaultClientId, 362 BrowserContext::GetDefaultStoragePartition( 363 browser_context())->GetPath()); 364 cache_ = ShaderCacheFactory::GetInstance()->Get(kDefaultClientId); 365 } 366 367 virtual ~StoragePartitionShaderClearTest() { 368 cache_ = NULL; 369 ShaderCacheFactory::GetInstance()->RemoveCacheInfo(kDefaultClientId); 370 } 371 372 void InitCache() { 373 net::TestCompletionCallback available_cb; 374 int rv = cache_->SetAvailableCallback(available_cb.callback()); 375 ASSERT_EQ(net::OK, available_cb.GetResult(rv)); 376 EXPECT_EQ(0, cache_->Size()); 377 378 cache_->Cache(kCacheKey, kCacheValue); 379 380 net::TestCompletionCallback complete_cb; 381 382 rv = cache_->SetCacheCompleteCallback(complete_cb.callback()); 383 ASSERT_EQ(net::OK, complete_cb.GetResult(rv)); 384 } 385 386 size_t Size() { return cache_->Size(); } 387 388 TestBrowserContext* browser_context() { 389 return browser_context_.get(); 390 } 391 392 private: 393 content::TestBrowserThreadBundle thread_bundle_; 394 scoped_ptr<TestBrowserContext> browser_context_; 395 396 scoped_refptr<ShaderDiskCache> cache_; 397}; 398 399// Tests --------------------------------------------------------------------- 400 401TEST_F(StoragePartitionShaderClearTest, ClearShaderCache) { 402 InitCache(); 403 EXPECT_EQ(1u, Size()); 404 405 base::RunLoop run_loop; 406 base::MessageLoop::current()->PostTask( 407 FROM_HERE, base::Bind( 408 &ClearData, 409 BrowserContext::GetDefaultStoragePartition(browser_context()), 410 &run_loop)); 411 run_loop.Run(); 412 EXPECT_EQ(0u, Size()); 413} 414 415TEST_F(StoragePartitionImplTest, QuotaClientMaskGeneration) { 416 EXPECT_EQ(storage::QuotaClient::kFileSystem, 417 StoragePartitionImpl::GenerateQuotaClientMask( 418 StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS)); 419 EXPECT_EQ(storage::QuotaClient::kDatabase, 420 StoragePartitionImpl::GenerateQuotaClientMask( 421 StoragePartition::REMOVE_DATA_MASK_WEBSQL)); 422 EXPECT_EQ(storage::QuotaClient::kAppcache, 423 StoragePartitionImpl::GenerateQuotaClientMask( 424 StoragePartition::REMOVE_DATA_MASK_APPCACHE)); 425 EXPECT_EQ(storage::QuotaClient::kIndexedDatabase, 426 StoragePartitionImpl::GenerateQuotaClientMask( 427 StoragePartition::REMOVE_DATA_MASK_INDEXEDDB)); 428 EXPECT_EQ(storage::QuotaClient::kFileSystem | 429 storage::QuotaClient::kDatabase | 430 storage::QuotaClient::kAppcache | 431 storage::QuotaClient::kIndexedDatabase, 432 StoragePartitionImpl::GenerateQuotaClientMask(kAllQuotaRemoveMask)); 433} 434 435void PopulateTestQuotaManagedPersistentData(MockQuotaManager* manager) { 436 manager->AddOrigin(kOrigin2, kPersistent, kClientFile, base::Time()); 437 manager->AddOrigin(kOrigin3, kPersistent, kClientFile, 438 base::Time::Now() - base::TimeDelta::FromDays(1)); 439 440 EXPECT_FALSE(manager->OriginHasData(kOrigin1, kPersistent, kClientFile)); 441 EXPECT_TRUE(manager->OriginHasData(kOrigin2, kPersistent, kClientFile)); 442 EXPECT_TRUE(manager->OriginHasData(kOrigin3, kPersistent, kClientFile)); 443} 444 445void PopulateTestQuotaManagedTemporaryData(MockQuotaManager* manager) { 446 manager->AddOrigin(kOrigin1, kTemporary, kClientFile, base::Time::Now()); 447 manager->AddOrigin(kOrigin3, kTemporary, kClientFile, 448 base::Time::Now() - base::TimeDelta::FromDays(1)); 449 450 EXPECT_TRUE(manager->OriginHasData(kOrigin1, kTemporary, kClientFile)); 451 EXPECT_FALSE(manager->OriginHasData(kOrigin2, kTemporary, kClientFile)); 452 EXPECT_TRUE(manager->OriginHasData(kOrigin3, kTemporary, kClientFile)); 453} 454 455void PopulateTestQuotaManagedData(MockQuotaManager* manager) { 456 // Set up kOrigin1 with a temporary quota, kOrigin2 with a persistent 457 // quota, and kOrigin3 with both. kOrigin1 is modified now, kOrigin2 458 // is modified at the beginning of time, and kOrigin3 is modified one day 459 // ago. 460 PopulateTestQuotaManagedPersistentData(manager); 461 PopulateTestQuotaManagedTemporaryData(manager); 462} 463 464void PopulateTestQuotaManagedNonBrowsingData(MockQuotaManager* manager) { 465 manager->AddOrigin(kOriginDevTools, kTemporary, kClientFile, base::Time()); 466 manager->AddOrigin(kOriginDevTools, kPersistent, kClientFile, base::Time()); 467} 468 469TEST_F(StoragePartitionImplTest, RemoveQuotaManagedDataForeverBoth) { 470 PopulateTestQuotaManagedData(GetMockManager()); 471 472 StoragePartitionImpl* partition = static_cast<StoragePartitionImpl*>( 473 BrowserContext::GetDefaultStoragePartition(browser_context())); 474 partition->OverrideQuotaManagerForTesting( 475 GetMockManager()); 476 477 base::RunLoop run_loop; 478 base::MessageLoop::current()->PostTask( 479 FROM_HERE, base::Bind(&ClearQuotaData, partition, &run_loop)); 480 run_loop.Run(); 481 482 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1, kTemporary, 483 kClientFile)); 484 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2, kTemporary, 485 kClientFile)); 486 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3, kTemporary, 487 kClientFile)); 488 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1, kPersistent, 489 kClientFile)); 490 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2, kPersistent, 491 kClientFile)); 492 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3, kPersistent, 493 kClientFile)); 494} 495 496TEST_F(StoragePartitionImplTest, RemoveQuotaManagedDataForeverOnlyTemporary) { 497 PopulateTestQuotaManagedTemporaryData(GetMockManager()); 498 499 StoragePartitionImpl* partition = static_cast<StoragePartitionImpl*>( 500 BrowserContext::GetDefaultStoragePartition(browser_context())); 501 partition->OverrideQuotaManagerForTesting( 502 GetMockManager()); 503 504 base::RunLoop run_loop; 505 base::MessageLoop::current()->PostTask( 506 FROM_HERE, base::Bind(&ClearQuotaData, partition, &run_loop)); 507 run_loop.Run(); 508 509 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1, kTemporary, 510 kClientFile)); 511 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2, kTemporary, 512 kClientFile)); 513 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3, kTemporary, 514 kClientFile)); 515 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1, kPersistent, 516 kClientFile)); 517 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2, kPersistent, 518 kClientFile)); 519 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3, kPersistent, 520 kClientFile)); 521} 522 523TEST_F(StoragePartitionImplTest, RemoveQuotaManagedDataForeverOnlyPersistent) { 524 PopulateTestQuotaManagedPersistentData(GetMockManager()); 525 526 StoragePartitionImpl* partition = static_cast<StoragePartitionImpl*>( 527 BrowserContext::GetDefaultStoragePartition(browser_context())); 528 partition->OverrideQuotaManagerForTesting( 529 GetMockManager()); 530 531 base::RunLoop run_loop; 532 base::MessageLoop::current()->PostTask( 533 FROM_HERE, base::Bind(&ClearQuotaData, partition, &run_loop)); 534 run_loop.Run(); 535 536 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1, kTemporary, 537 kClientFile)); 538 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2, kTemporary, 539 kClientFile)); 540 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3, kTemporary, 541 kClientFile)); 542 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1, kPersistent, 543 kClientFile)); 544 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2, kPersistent, 545 kClientFile)); 546 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3, kPersistent, 547 kClientFile)); 548} 549 550TEST_F(StoragePartitionImplTest, RemoveQuotaManagedDataForeverNeither) { 551 StoragePartitionImpl* partition = static_cast<StoragePartitionImpl*>( 552 BrowserContext::GetDefaultStoragePartition(browser_context())); 553 partition->OverrideQuotaManagerForTesting( 554 GetMockManager()); 555 556 base::RunLoop run_loop; 557 base::MessageLoop::current()->PostTask( 558 FROM_HERE, base::Bind(&ClearQuotaData, partition, &run_loop)); 559 run_loop.Run(); 560 561 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1, kTemporary, 562 kClientFile)); 563 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2, kTemporary, 564 kClientFile)); 565 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3, kTemporary, 566 kClientFile)); 567 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1, kPersistent, 568 kClientFile)); 569 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2, kPersistent, 570 kClientFile)); 571 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3, kPersistent, 572 kClientFile)); 573} 574 575TEST_F(StoragePartitionImplTest, RemoveQuotaManagedDataForeverSpecificOrigin) { 576 PopulateTestQuotaManagedData(GetMockManager()); 577 578 StoragePartitionImpl* partition = static_cast<StoragePartitionImpl*>( 579 BrowserContext::GetDefaultStoragePartition(browser_context())); 580 partition->OverrideQuotaManagerForTesting( 581 GetMockManager()); 582 583 base::RunLoop run_loop; 584 base::MessageLoop::current()->PostTask( 585 FROM_HERE, base::Bind(&ClearQuotaDataForOrigin, 586 partition, kOrigin1, base::Time(), 587 &run_loop)); 588 run_loop.Run(); 589 590 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1, kTemporary, 591 kClientFile)); 592 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2, kTemporary, 593 kClientFile)); 594 EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin3, kTemporary, 595 kClientFile)); 596 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1, kPersistent, 597 kClientFile)); 598 EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin2, kPersistent, 599 kClientFile)); 600 EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin3, kPersistent, 601 kClientFile)); 602} 603 604TEST_F(StoragePartitionImplTest, RemoveQuotaManagedDataForLastHour) { 605 PopulateTestQuotaManagedData(GetMockManager()); 606 607 StoragePartitionImpl* partition = static_cast<StoragePartitionImpl*>( 608 BrowserContext::GetDefaultStoragePartition(browser_context())); 609 partition->OverrideQuotaManagerForTesting( 610 GetMockManager()); 611 612 base::RunLoop run_loop; 613 base::MessageLoop::current()->PostTask( 614 FROM_HERE, base::Bind(&ClearQuotaDataForOrigin, 615 partition, GURL(), 616 base::Time::Now() - base::TimeDelta::FromHours(1), 617 &run_loop)); 618 run_loop.Run(); 619 620 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1, kTemporary, 621 kClientFile)); 622 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2, kTemporary, 623 kClientFile)); 624 EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin3, kTemporary, 625 kClientFile)); 626 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1, kPersistent, 627 kClientFile)); 628 EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin2, kPersistent, 629 kClientFile)); 630 EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin3, kPersistent, 631 kClientFile)); 632} 633 634TEST_F(StoragePartitionImplTest, RemoveQuotaManagedDataForLastWeek) { 635 PopulateTestQuotaManagedData(GetMockManager()); 636 637 base::RunLoop run_loop; 638 StoragePartitionImpl* partition = static_cast<StoragePartitionImpl*>( 639 BrowserContext::GetDefaultStoragePartition(browser_context())); 640 partition->OverrideQuotaManagerForTesting( 641 GetMockManager()); 642 base::MessageLoop::current()->PostTask( 643 FROM_HERE, base::Bind(&ClearQuotaDataForNonPersistent, 644 partition, 645 base::Time::Now() - base::TimeDelta::FromDays(7), 646 &run_loop)); 647 run_loop.Run(); 648 649 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1, kTemporary, 650 kClientFile)); 651 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2, kTemporary, 652 kClientFile)); 653 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3, kTemporary, 654 kClientFile)); 655 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1, kPersistent, 656 kClientFile)); 657 EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin2, kPersistent, 658 kClientFile)); 659 EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin3, kPersistent, 660 kClientFile)); 661} 662 663TEST_F(StoragePartitionImplTest, RemoveQuotaManagedUnprotectedOrigins) { 664 // Protect kOrigin1. 665 scoped_refptr<MockSpecialStoragePolicy> mock_policy = 666 new MockSpecialStoragePolicy; 667 mock_policy->AddProtected(kOrigin1.GetOrigin()); 668 669 PopulateTestQuotaManagedData(GetMockManager()); 670 671 StoragePartitionImpl* partition = static_cast<StoragePartitionImpl*>( 672 BrowserContext::GetDefaultStoragePartition(browser_context())); 673 partition->OverrideQuotaManagerForTesting( 674 GetMockManager()); 675 partition->OverrideSpecialStoragePolicyForTesting(mock_policy.get()); 676 677 base::RunLoop run_loop; 678 base::MessageLoop::current()->PostTask( 679 FROM_HERE, base::Bind(&ClearQuotaDataWithOriginMatcher, 680 partition, GURL(), 681 base::Bind(&DoesOriginMatchForUnprotectedWeb), 682 base::Time(), &run_loop)); 683 run_loop.Run(); 684 685 EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin1, kTemporary, 686 kClientFile)); 687 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2, kTemporary, 688 kClientFile)); 689 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3, kTemporary, 690 kClientFile)); 691 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1, kPersistent, 692 kClientFile)); 693 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2, kPersistent, 694 kClientFile)); 695 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3, kPersistent, 696 kClientFile)); 697} 698 699TEST_F(StoragePartitionImplTest, RemoveQuotaManagedProtectedSpecificOrigin) { 700 // Protect kOrigin1. 701 scoped_refptr<MockSpecialStoragePolicy> mock_policy = 702 new MockSpecialStoragePolicy; 703 mock_policy->AddProtected(kOrigin1.GetOrigin()); 704 705 PopulateTestQuotaManagedData(GetMockManager()); 706 707 StoragePartitionImpl* partition = static_cast<StoragePartitionImpl*>( 708 BrowserContext::GetDefaultStoragePartition(browser_context())); 709 partition->OverrideQuotaManagerForTesting( 710 GetMockManager()); 711 partition->OverrideSpecialStoragePolicyForTesting(mock_policy.get()); 712 713 // Try to remove kOrigin1. Expect failure. 714 base::RunLoop run_loop; 715 base::MessageLoop::current()->PostTask( 716 FROM_HERE, base::Bind(&ClearQuotaDataWithOriginMatcher, 717 partition, kOrigin1, 718 base::Bind(&DoesOriginMatchForUnprotectedWeb), 719 base::Time(), &run_loop)); 720 run_loop.Run(); 721 722 EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin1, kTemporary, 723 kClientFile)); 724 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2, kTemporary, 725 kClientFile)); 726 EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin3, kTemporary, 727 kClientFile)); 728 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1, kPersistent, 729 kClientFile)); 730 EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin2, kPersistent, 731 kClientFile)); 732 EXPECT_TRUE(GetMockManager()->OriginHasData(kOrigin3, kPersistent, 733 kClientFile)); 734} 735 736TEST_F(StoragePartitionImplTest, RemoveQuotaManagedProtectedOrigins) { 737 // Protect kOrigin1. 738 scoped_refptr<MockSpecialStoragePolicy> mock_policy = 739 new MockSpecialStoragePolicy; 740 mock_policy->AddProtected(kOrigin1.GetOrigin()); 741 742 PopulateTestQuotaManagedData(GetMockManager()); 743 744 // Try to remove kOrigin1. Expect success. 745 base::RunLoop run_loop; 746 StoragePartitionImpl* partition = static_cast<StoragePartitionImpl*>( 747 BrowserContext::GetDefaultStoragePartition(browser_context())); 748 partition->OverrideQuotaManagerForTesting( 749 GetMockManager()); 750 partition->OverrideSpecialStoragePolicyForTesting(mock_policy.get()); 751 base::MessageLoop::current()->PostTask( 752 FROM_HERE, 753 base::Bind(&ClearQuotaDataWithOriginMatcher, 754 partition, GURL(), 755 base::Bind(&DoesOriginMatchForBothProtectedAndUnprotectedWeb), 756 base::Time(), &run_loop)); 757 run_loop.Run(); 758 759 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1, kTemporary, 760 kClientFile)); 761 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2, kTemporary, 762 kClientFile)); 763 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3, kTemporary, 764 kClientFile)); 765 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin1, kPersistent, 766 kClientFile)); 767 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin2, kPersistent, 768 kClientFile)); 769 EXPECT_FALSE(GetMockManager()->OriginHasData(kOrigin3, kPersistent, 770 kClientFile)); 771} 772 773TEST_F(StoragePartitionImplTest, RemoveQuotaManagedIgnoreDevTools) { 774 PopulateTestQuotaManagedNonBrowsingData(GetMockManager()); 775 776 base::RunLoop run_loop; 777 StoragePartitionImpl* partition = static_cast<StoragePartitionImpl*>( 778 BrowserContext::GetDefaultStoragePartition(browser_context())); 779 partition->OverrideQuotaManagerForTesting( 780 GetMockManager()); 781 base::MessageLoop::current()->PostTask( 782 FROM_HERE, base::Bind(&ClearQuotaDataWithOriginMatcher, 783 partition, GURL(), 784 base::Bind(&DoesOriginMatchUnprotected), 785 base::Time(), &run_loop)); 786 run_loop.Run(); 787 788 // Check that devtools data isn't removed. 789 EXPECT_TRUE(GetMockManager()->OriginHasData(kOriginDevTools, kTemporary, 790 kClientFile)); 791 EXPECT_TRUE(GetMockManager()->OriginHasData(kOriginDevTools, kPersistent, 792 kClientFile)); 793} 794 795TEST_F(StoragePartitionImplTest, RemoveCookieForever) { 796 RemoveCookieTester tester(browser_context()); 797 798 tester.AddCookie(); 799 ASSERT_TRUE(tester.ContainsCookie()); 800 801 StoragePartitionImpl* partition = static_cast<StoragePartitionImpl*>( 802 BrowserContext::GetDefaultStoragePartition(browser_context())); 803 partition->SetURLRequestContext(browser_context()->GetRequestContext()); 804 805 base::RunLoop run_loop; 806 base::MessageLoop::current()->PostTask( 807 FROM_HERE, base::Bind(&ClearCookies, 808 partition, base::Time(), base::Time::Max(), 809 &run_loop)); 810 run_loop.Run(); 811 812 EXPECT_FALSE(tester.ContainsCookie()); 813} 814 815TEST_F(StoragePartitionImplTest, RemoveCookieLastHour) { 816 RemoveCookieTester tester(browser_context()); 817 818 tester.AddCookie(); 819 ASSERT_TRUE(tester.ContainsCookie()); 820 821 StoragePartitionImpl* partition = static_cast<StoragePartitionImpl*>( 822 BrowserContext::GetDefaultStoragePartition(browser_context())); 823 base::Time an_hour_ago = base::Time::Now() - base::TimeDelta::FromHours(1); 824 partition->SetURLRequestContext(browser_context()->GetRequestContext()); 825 826 base::RunLoop run_loop; 827 base::MessageLoop::current()->PostTask( 828 FROM_HERE, base::Bind(&ClearCookies, 829 partition, an_hour_ago, base::Time::Max(), 830 &run_loop)); 831 run_loop.Run(); 832 833 EXPECT_FALSE(tester.ContainsCookie()); 834} 835 836TEST_F(StoragePartitionImplTest, RemoveUnprotectedLocalStorageForever) { 837 // Protect kOrigin1. 838 scoped_refptr<MockSpecialStoragePolicy> mock_policy = 839 new MockSpecialStoragePolicy; 840 mock_policy->AddProtected(kOrigin1.GetOrigin()); 841 842 RemoveLocalStorageTester tester(browser_context()); 843 844 tester.AddDOMStorageTestData(); 845 EXPECT_TRUE(tester.DOMStorageExistsForOrigin(kOrigin1)); 846 EXPECT_TRUE(tester.DOMStorageExistsForOrigin(kOrigin2)); 847 EXPECT_TRUE(tester.DOMStorageExistsForOrigin(kOrigin3)); 848 849 StoragePartitionImpl* partition = static_cast<StoragePartitionImpl*>( 850 BrowserContext::GetDefaultStoragePartition(browser_context())); 851 partition->OverrideSpecialStoragePolicyForTesting(mock_policy.get()); 852 853 base::RunLoop run_loop; 854 base::MessageLoop::current()->PostTask( 855 FROM_HERE, 856 base::Bind(&ClearStuff, 857 StoragePartitionImpl::REMOVE_DATA_MASK_LOCAL_STORAGE, 858 partition, base::Time(), base::Time::Max(), 859 base::Bind(&DoesOriginMatchForUnprotectedWeb), 860 &run_loop)); 861 run_loop.Run(); 862 863 EXPECT_TRUE(tester.DOMStorageExistsForOrigin(kOrigin1)); 864 EXPECT_FALSE(tester.DOMStorageExistsForOrigin(kOrigin2)); 865 EXPECT_FALSE(tester.DOMStorageExistsForOrigin(kOrigin3)); 866} 867 868TEST_F(StoragePartitionImplTest, RemoveProtectedLocalStorageForever) { 869 // Protect kOrigin1. 870 scoped_refptr<MockSpecialStoragePolicy> mock_policy = 871 new MockSpecialStoragePolicy; 872 mock_policy->AddProtected(kOrigin1.GetOrigin()); 873 874 RemoveLocalStorageTester tester(browser_context()); 875 876 tester.AddDOMStorageTestData(); 877 EXPECT_TRUE(tester.DOMStorageExistsForOrigin(kOrigin1)); 878 EXPECT_TRUE(tester.DOMStorageExistsForOrigin(kOrigin2)); 879 EXPECT_TRUE(tester.DOMStorageExistsForOrigin(kOrigin3)); 880 881 StoragePartitionImpl* partition = static_cast<StoragePartitionImpl*>( 882 BrowserContext::GetDefaultStoragePartition(browser_context())); 883 partition->OverrideSpecialStoragePolicyForTesting(mock_policy.get()); 884 885 base::RunLoop run_loop; 886 base::MessageLoop::current()->PostTask( 887 FROM_HERE, 888 base::Bind(&ClearStuff, 889 StoragePartitionImpl::REMOVE_DATA_MASK_LOCAL_STORAGE, 890 partition, base::Time(), base::Time::Max(), 891 base::Bind(&DoesOriginMatchForBothProtectedAndUnprotectedWeb), 892 &run_loop)); 893 run_loop.Run(); 894 895 // Even if kOrigin1 is protected, it will be deleted since we specify 896 // ClearData to delete protected data. 897 EXPECT_FALSE(tester.DOMStorageExistsForOrigin(kOrigin1)); 898 EXPECT_FALSE(tester.DOMStorageExistsForOrigin(kOrigin2)); 899 EXPECT_FALSE(tester.DOMStorageExistsForOrigin(kOrigin3)); 900} 901 902TEST_F(StoragePartitionImplTest, RemoveLocalStorageForLastWeek) { 903 RemoveLocalStorageTester tester(browser_context()); 904 905 tester.AddDOMStorageTestData(); 906 EXPECT_TRUE(tester.DOMStorageExistsForOrigin(kOrigin1)); 907 EXPECT_TRUE(tester.DOMStorageExistsForOrigin(kOrigin2)); 908 EXPECT_TRUE(tester.DOMStorageExistsForOrigin(kOrigin3)); 909 910 StoragePartitionImpl* partition = static_cast<StoragePartitionImpl*>( 911 BrowserContext::GetDefaultStoragePartition(browser_context())); 912 base::Time a_week_ago = base::Time::Now() - base::TimeDelta::FromDays(7); 913 914 base::RunLoop run_loop; 915 base::MessageLoop::current()->PostTask( 916 FROM_HERE, 917 base::Bind(&ClearStuff, 918 StoragePartitionImpl::REMOVE_DATA_MASK_LOCAL_STORAGE, 919 partition, a_week_ago, base::Time::Max(), 920 base::Bind(&DoesOriginMatchForBothProtectedAndUnprotectedWeb), 921 &run_loop)); 922 run_loop.Run(); 923 924 // kOrigin1 and kOrigin2 do not have age more than a week. 925 EXPECT_FALSE(tester.DOMStorageExistsForOrigin(kOrigin1)); 926 EXPECT_FALSE(tester.DOMStorageExistsForOrigin(kOrigin2)); 927 EXPECT_TRUE(tester.DOMStorageExistsForOrigin(kOrigin3)); 928} 929 930} // namespace content 931