| // Copyright 2013 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 "content/browser/dom_storage/dom_storage_context_impl.h" |
| #include "base/bind.h" |
| #include "base/files/file_util.h" |
| #include "base/files/scoped_temp_dir.h" |
| #include "base/macros.h" |
| #include "base/message_loop/message_loop.h" |
| #include "base/run_loop.h" |
| #include "base/strings/utf_string_conversions.h" |
| #include "base/threading/thread_task_runner_handle.h" |
| #include "base/time/time.h" |
| #include "build/build_config.h" |
| #include "content/browser/dom_storage/dom_storage_area.h" |
| #include "content/browser/dom_storage/dom_storage_namespace.h" |
| #include "content/browser/dom_storage/dom_storage_task_runner.h" |
| #include "content/public/browser/local_storage_usage_info.h" |
| #include "content/public/browser/session_storage_usage_info.h" |
| #include "storage/browser/test/mock_special_storage_policy.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "url/gurl.h" |
| #include "url/origin.h" |
| |
| using base::ASCIIToUTF16; |
| |
| namespace content { |
| |
| class DOMStorageContextImplTest : public testing::Test { |
| public: |
| DOMStorageContextImplTest() |
| : kOrigin(GURL("http://dom_storage/")), |
| kSuborigin(GURL("http-so://foobar.dom_storage/")), |
| kKey(ASCIIToUTF16("key")), |
| kValue(ASCIIToUTF16("value")), |
| kDontIncludeFileInfo(false), |
| kDoIncludeFileInfo(true) {} |
| |
| const GURL kOrigin; |
| const GURL kSuborigin; |
| const base::string16 kKey; |
| const base::string16 kValue; |
| const bool kDontIncludeFileInfo; |
| const bool kDoIncludeFileInfo; |
| |
| void SetUp() override { |
| ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); |
| storage_policy_ = new MockSpecialStoragePolicy; |
| task_runner_ = |
| new MockDOMStorageTaskRunner(base::ThreadTaskRunnerHandle::Get().get()); |
| context_ = |
| new DOMStorageContextImpl(temp_dir_.GetPath(), base::FilePath(), |
| storage_policy_.get(), task_runner_.get()); |
| } |
| |
| void TearDown() override { |
| if (context_) |
| context_->Shutdown(); |
| base::RunLoop().RunUntilIdle(); |
| } |
| |
| void VerifySingleOriginRemains(const GURL& origin) { |
| // Use a new instance to examine the contexts of temp_dir_. |
| scoped_refptr<DOMStorageContextImpl> context = new DOMStorageContextImpl( |
| temp_dir_.GetPath(), base::FilePath(), nullptr, nullptr); |
| std::vector<LocalStorageUsageInfo> infos; |
| context->GetLocalStorageUsage(&infos, kDontIncludeFileInfo); |
| ASSERT_EQ(1u, infos.size()); |
| EXPECT_EQ(origin, infos[0].origin); |
| context->Shutdown(); |
| } |
| |
| int session_id_offset() { return context_->session_id_offset_; } |
| |
| protected: |
| base::MessageLoop message_loop_; |
| base::ScopedTempDir temp_dir_; |
| scoped_refptr<MockSpecialStoragePolicy> storage_policy_; |
| scoped_refptr<MockDOMStorageTaskRunner> task_runner_; |
| scoped_refptr<DOMStorageContextImpl> context_; |
| DISALLOW_COPY_AND_ASSIGN(DOMStorageContextImplTest); |
| }; |
| |
| TEST_F(DOMStorageContextImplTest, Basics) { |
| // This test doesn't do much, checks that the constructor |
| // initializes members properly and that invoking methods |
| // on a newly created object w/o any data on disk do no harm. |
| EXPECT_EQ(temp_dir_.GetPath(), context_->localstorage_directory()); |
| EXPECT_EQ(base::FilePath(), context_->sessionstorage_directory()); |
| EXPECT_EQ(storage_policy_.get(), context_->special_storage_policy_.get()); |
| context_->DeleteLocalStorage(GURL("http://chromium.org/")); |
| const int kFirstSessionStorageNamespaceId = 1 + session_id_offset(); |
| EXPECT_TRUE(context_->GetStorageNamespace(kLocalStorageNamespaceId)); |
| EXPECT_FALSE(context_->GetStorageNamespace(kFirstSessionStorageNamespaceId)); |
| EXPECT_EQ(kFirstSessionStorageNamespaceId, context_->AllocateSessionId()); |
| std::vector<LocalStorageUsageInfo> infos; |
| context_->GetLocalStorageUsage(&infos, kDontIncludeFileInfo); |
| EXPECT_TRUE(infos.empty()); |
| context_->Shutdown(); |
| } |
| |
| TEST_F(DOMStorageContextImplTest, UsageInfo) { |
| // Should be empty initially |
| std::vector<LocalStorageUsageInfo> infos; |
| context_->GetLocalStorageUsage(&infos, kDontIncludeFileInfo); |
| EXPECT_TRUE(infos.empty()); |
| context_->GetLocalStorageUsage(&infos, kDoIncludeFileInfo); |
| EXPECT_TRUE(infos.empty()); |
| |
| // Put some data into local storage and shutdown the context |
| // to ensure data is written to disk. |
| base::NullableString16 old_value; |
| EXPECT_TRUE(context_->GetStorageNamespace(kLocalStorageNamespaceId) |
| ->OpenStorageArea(kOrigin) |
| ->SetItem(kKey, kValue, old_value, &old_value)); |
| context_->Shutdown(); |
| context_ = nullptr; |
| base::RunLoop().RunUntilIdle(); |
| |
| // Create a new context that points to the same directory, see that |
| // it knows about the origin that we stored data for. |
| context_ = new DOMStorageContextImpl(temp_dir_.GetPath(), base::FilePath(), |
| nullptr, nullptr); |
| context_->GetLocalStorageUsage(&infos, kDontIncludeFileInfo); |
| EXPECT_EQ(1u, infos.size()); |
| EXPECT_EQ(kOrigin, infos[0].origin); |
| EXPECT_EQ(0u, infos[0].data_size); |
| EXPECT_EQ(base::Time(), infos[0].last_modified); |
| infos.clear(); |
| context_->GetLocalStorageUsage(&infos, kDoIncludeFileInfo); |
| EXPECT_EQ(1u, infos.size()); |
| EXPECT_EQ(kOrigin, infos[0].origin); |
| EXPECT_NE(0u, infos[0].data_size); |
| EXPECT_NE(base::Time(), infos[0].last_modified); |
| } |
| |
| TEST_F(DOMStorageContextImplTest, SessionOnly) { |
| const GURL kSessionOnlyOrigin("http://www.sessiononly.com/"); |
| storage_policy_->AddSessionOnly(kSessionOnlyOrigin); |
| |
| // Store data for a normal and a session-only origin and then |
| // invoke Shutdown() which should delete data for session-only |
| // origins. |
| base::NullableString16 old_value; |
| EXPECT_TRUE(context_->GetStorageNamespace(kLocalStorageNamespaceId) |
| ->OpenStorageArea(kOrigin) |
| ->SetItem(kKey, kValue, old_value, &old_value)); |
| EXPECT_TRUE(context_->GetStorageNamespace(kLocalStorageNamespaceId) |
| ->OpenStorageArea(kSessionOnlyOrigin) |
| ->SetItem(kKey, kValue, old_value, &old_value)); |
| context_->Shutdown(); |
| context_ = nullptr; |
| base::RunLoop().RunUntilIdle(); |
| |
| // Verify that the session-only origin data is gone. |
| VerifySingleOriginRemains(kOrigin); |
| } |
| |
| TEST_F(DOMStorageContextImplTest, SetForceKeepSessionState) { |
| const GURL kSessionOnlyOrigin("http://www.sessiononly.com/"); |
| storage_policy_->AddSessionOnly(kSessionOnlyOrigin); |
| |
| // Store data for a session-only origin, setup to save session data, then |
| // shutdown. |
| base::NullableString16 old_value; |
| EXPECT_TRUE(context_->GetStorageNamespace(kLocalStorageNamespaceId) |
| ->OpenStorageArea(kSessionOnlyOrigin) |
| ->SetItem(kKey, kValue, old_value, &old_value)); |
| context_->SetForceKeepSessionState(); // Should override clear behavior. |
| context_->Shutdown(); |
| context_ = nullptr; |
| base::RunLoop().RunUntilIdle(); |
| |
| VerifySingleOriginRemains(kSessionOnlyOrigin); |
| } |
| |
| TEST_F(DOMStorageContextImplTest, PersistentIds) { |
| const int kFirstSessionStorageNamespaceId = 1 + session_id_offset(); |
| const std::string kPersistentId = "persistent"; |
| context_->CreateSessionNamespace(kFirstSessionStorageNamespaceId, |
| kPersistentId); |
| DOMStorageNamespace* dom_namespace = |
| context_->GetStorageNamespace(kFirstSessionStorageNamespaceId); |
| ASSERT_TRUE(dom_namespace); |
| EXPECT_EQ(kPersistentId, dom_namespace->persistent_namespace_id()); |
| // Verify that the areas inherit the persistent ID. |
| DOMStorageArea* area = dom_namespace->OpenStorageArea(kOrigin); |
| EXPECT_EQ(kPersistentId, area->persistent_namespace_id_); |
| |
| // Verify that the persistent IDs are handled correctly when cloning. |
| const int kClonedSessionStorageNamespaceId = 2 + session_id_offset(); |
| const std::string kClonedPersistentId = "cloned"; |
| context_->CloneSessionNamespace(kFirstSessionStorageNamespaceId, |
| kClonedSessionStorageNamespaceId, |
| kClonedPersistentId); |
| DOMStorageNamespace* cloned_dom_namespace = |
| context_->GetStorageNamespace(kClonedSessionStorageNamespaceId); |
| ASSERT_TRUE(dom_namespace); |
| EXPECT_EQ(kClonedPersistentId, |
| cloned_dom_namespace->persistent_namespace_id()); |
| // Verify that the areas inherit the persistent ID. |
| DOMStorageArea* cloned_area = cloned_dom_namespace->OpenStorageArea(kOrigin); |
| EXPECT_EQ(kClonedPersistentId, cloned_area->persistent_namespace_id_); |
| } |
| |
| // Disable this test on Android as on Android we always delete our old session |
| // storage on startup. This is because we don't do any session restoration for |
| // the android system. See crbug.com/770307. |
| #if defined(OS_ANDROID) |
| TEST_F(DOMStorageContextImplTest, DISABLED_DeleteSessionStorage) { |
| #else |
| TEST_F(DOMStorageContextImplTest, DeleteSessionStorage) { |
| #endif |
| // Create a DOMStorageContextImpl which will save sessionStorage on disk. |
| context_->Shutdown(); |
| context_ = |
| new DOMStorageContextImpl(temp_dir_.GetPath(), temp_dir_.GetPath(), |
| storage_policy_.get(), task_runner_.get()); |
| context_->SetSaveSessionStorageOnDisk(); |
| ASSERT_EQ(temp_dir_.GetPath(), context_->sessionstorage_directory()); |
| |
| // Write data. |
| const int kSessionStorageNamespaceId = 1 + session_id_offset(); |
| const std::string kPersistentId = "persistent"; |
| context_->CreateSessionNamespace(kSessionStorageNamespaceId, |
| kPersistentId); |
| DOMStorageNamespace* dom_namespace = |
| context_->GetStorageNamespace(kSessionStorageNamespaceId); |
| DOMStorageArea* area = dom_namespace->OpenStorageArea(kOrigin); |
| const base::string16 kKey(ASCIIToUTF16("foo")); |
| const base::string16 kValue(ASCIIToUTF16("bar")); |
| base::NullableString16 old_nullable_value; |
| area->SetItem(kKey, kValue, old_nullable_value, &old_nullable_value); |
| dom_namespace->CloseStorageArea(area); |
| |
| // Destroy and recreate the DOMStorageContextImpl. |
| context_->Shutdown(); |
| context_ = nullptr; |
| base::RunLoop().RunUntilIdle(); |
| context_ = |
| new DOMStorageContextImpl(temp_dir_.GetPath(), temp_dir_.GetPath(), |
| storage_policy_.get(), task_runner_.get()); |
| context_->SetSaveSessionStorageOnDisk(); |
| |
| // Read the data back. |
| context_->CreateSessionNamespace(kSessionStorageNamespaceId, |
| kPersistentId); |
| dom_namespace = context_->GetStorageNamespace(kSessionStorageNamespaceId); |
| area = dom_namespace->OpenStorageArea(kOrigin); |
| base::NullableString16 read_value; |
| EXPECT_EQ(kKey, area->Key(0).string()); |
| dom_namespace->CloseStorageArea(area); |
| |
| SessionStorageUsageInfo info; |
| info.origin = kOrigin; |
| info.persistent_namespace_id = kPersistentId; |
| context_->DeleteSessionStorage(info); |
| |
| // Destroy and recreate again. |
| context_->Shutdown(); |
| context_ = nullptr; |
| base::RunLoop().RunUntilIdle(); |
| context_ = |
| new DOMStorageContextImpl(temp_dir_.GetPath(), temp_dir_.GetPath(), |
| storage_policy_.get(), task_runner_.get()); |
| context_->SetSaveSessionStorageOnDisk(); |
| |
| // Now there should be no data. |
| context_->CreateSessionNamespace(kSessionStorageNamespaceId, |
| kPersistentId); |
| dom_namespace = context_->GetStorageNamespace(kSessionStorageNamespaceId); |
| area = dom_namespace->OpenStorageArea(kOrigin); |
| |
| EXPECT_EQ(0u, area->Length()); |
| dom_namespace->CloseStorageArea(area); |
| context_->Shutdown(); |
| context_ = nullptr; |
| base::RunLoop().RunUntilIdle(); |
| } |
| |
| TEST_F(DOMStorageContextImplTest, PurgeMemory) { |
| auto* dom_namespace = context_->GetStorageNamespace(kLocalStorageNamespaceId); |
| auto* area1 = dom_namespace->OpenStorageArea(kOrigin); |
| base::NullableString16 old_value; |
| area1->SetItem(kKey, kValue, old_value, &old_value); |
| |
| // PURGE_UNOPENED does not delete the open area. |
| context_->PurgeMemory(DOMStorageContextImpl::PURGE_UNOPENED); |
| EXPECT_EQ(1u, dom_namespace->GetUsageStatistics().total_area_count); |
| EXPECT_EQ(0u, dom_namespace->GetUsageStatistics().inactive_area_count); |
| |
| // PURGE_UNOPENED deletes the unopened area. |
| dom_namespace->CloseStorageArea(area1); |
| EXPECT_EQ(1u, dom_namespace->GetUsageStatistics().inactive_area_count); |
| area1->CommitChanges(area1->GetCurrentCommitBatch()->batch.get()); |
| area1->commit_batches_.clear(); |
| context_->PurgeMemory(DOMStorageContextImpl::PURGE_UNOPENED); |
| EXPECT_EQ(0u, dom_namespace->GetUsageStatistics().total_area_count); |
| |
| // Add an item to the database and commit changes, and keep it open. So, cache |
| // is kept alive. |
| auto* area2 = dom_namespace->OpenStorageArea(kOrigin); |
| area2->SetItem(kKey, kValue, old_value, &old_value); |
| area2->CommitChanges(area2->GetCurrentCommitBatch()->batch.get()); |
| area2->commit_batches_.clear(); |
| |
| // PURGE_AGGRESSIVE clears the cache in the open area. |
| EXPECT_NE(0u, dom_namespace->GetUsageStatistics().total_cache_size); |
| context_->PurgeMemory(DOMStorageContextImpl::PURGE_AGGRESSIVE); |
| EXPECT_EQ(0u, dom_namespace->GetUsageStatistics().total_cache_size); |
| } |
| |
| // Verifies that deleting the local storage for an origin will delete any |
| // suborigins also present, and similarly, deleting a suborigin will delete the |
| // physical origin as well. |
| TEST_F(DOMStorageContextImplTest, DeleteSuboriginLocalStorage) { |
| context_->Shutdown(); |
| context_ = |
| new DOMStorageContextImpl(temp_dir_.GetPath(), temp_dir_.GetPath(), |
| storage_policy_.get(), task_runner_.get()); |
| |
| DOMStorageNamespace* dom_namespace = |
| context_->GetStorageNamespace(kLocalStorageNamespaceId); |
| DOMStorageArea* origin_area = dom_namespace->OpenStorageArea(kOrigin); |
| DOMStorageArea* suborigin_area = dom_namespace->OpenStorageArea(kSuborigin); |
| origin_area->SetCacheOnlyKeys(false); |
| suborigin_area->SetCacheOnlyKeys(false); |
| |
| const base::string16 kOriginKey(ASCIIToUTF16("foo")); |
| const base::string16 kOriginValue(ASCIIToUTF16("bar")); |
| const base::string16 kSuboriginKey(ASCIIToUTF16("foz")); |
| const base::string16 kSuboriginValue(ASCIIToUTF16("baz")); |
| base::NullableString16 old_nullable_value; |
| |
| // Setup data for the first deletion (of the origin rather than the suborigin) |
| origin_area->SetItem(kOriginKey, kOriginValue, old_nullable_value, |
| &old_nullable_value); |
| suborigin_area->SetItem(kSuboriginKey, kSuboriginValue, old_nullable_value, |
| &old_nullable_value); |
| |
| base::NullableString16 read_value; |
| read_value = origin_area->GetItem(kOriginKey); |
| EXPECT_EQ(kOriginValue, read_value.string()); |
| read_value = suborigin_area->GetItem(kSuboriginKey); |
| EXPECT_EQ(kSuboriginValue, read_value.string()); |
| |
| // Deleting the data for the physical origin should delete the data in the |
| // suborigin as well. |
| context_->DeleteLocalStorageForPhysicalOrigin(kOrigin); |
| |
| read_value = origin_area->GetItem(kOriginKey); |
| EXPECT_TRUE(read_value.is_null()); |
| read_value = suborigin_area->GetItem(kSuboriginKey); |
| EXPECT_TRUE(read_value.is_null()); |
| |
| // Setup data again for the second deletion (of the suborigin rather than the |
| // origin) |
| origin_area->SetItem(kOriginKey, kOriginValue, old_nullable_value, |
| &old_nullable_value); |
| suborigin_area->SetItem(kSuboriginKey, kSuboriginValue, old_nullable_value, |
| &old_nullable_value); |
| |
| read_value = origin_area->GetItem(kOriginKey); |
| EXPECT_EQ(kOriginValue, read_value.string()); |
| read_value = suborigin_area->GetItem(kSuboriginKey); |
| EXPECT_EQ(kSuboriginValue, read_value.string()); |
| |
| // Delete the suborigin by physical origin this time. This should delete both |
| // the suborigin and physical origin. |
| context_->DeleteLocalStorageForPhysicalOrigin(kSuborigin); |
| |
| read_value = origin_area->GetItem(kOriginKey); |
| EXPECT_TRUE(read_value.is_null()); |
| read_value = suborigin_area->GetItem(kSuboriginKey); |
| EXPECT_TRUE(read_value.is_null()); |
| |
| // Setup data again for the third deletion, to test deleting the storage one |
| // at a time. |
| origin_area->SetItem(kOriginKey, kOriginValue, old_nullable_value, |
| &old_nullable_value); |
| suborigin_area->SetItem(kSuboriginKey, kSuboriginValue, old_nullable_value, |
| &old_nullable_value); |
| |
| read_value = origin_area->GetItem(kOriginKey); |
| EXPECT_EQ(kOriginValue, read_value.string()); |
| read_value = suborigin_area->GetItem(kSuboriginKey); |
| EXPECT_EQ(kSuboriginValue, read_value.string()); |
| |
| // Delete the origin only. This should leave the suborigin. |
| context_->DeleteLocalStorage(kOrigin); |
| |
| read_value = origin_area->GetItem(kOriginKey); |
| EXPECT_TRUE(read_value.is_null()); |
| read_value = suborigin_area->GetItem(kSuboriginKey); |
| EXPECT_EQ(kSuboriginValue, read_value.string()); |
| |
| // Put the origin value back so suborigin deletion can be tested. |
| origin_area->SetItem(kOriginKey, kOriginValue, old_nullable_value, |
| &old_nullable_value); |
| |
| read_value = origin_area->GetItem(kOriginKey); |
| EXPECT_EQ(kOriginValue, read_value.string()); |
| |
| // Delete the suborigin only. This should leave the origin. |
| context_->DeleteLocalStorage(kSuborigin); |
| |
| read_value = origin_area->GetItem(kOriginKey); |
| EXPECT_EQ(kOriginValue, read_value.string()); |
| read_value = suborigin_area->GetItem(kSuboriginKey); |
| EXPECT_TRUE(read_value.is_null()); |
| } |
| |
| } // namespace content |