blob: d29741f62ea42404e46fe556ccad5775427cb9b8 [file] [log] [blame]
// 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 "base/bind.h"
#include "base/file_util.h"
#include "base/files/scoped_temp_dir.h"
#include "base/message_loop/message_loop.h"
#include "base/message_loop/message_loop_proxy.h"
#include "base/strings/utf_string_conversions.h"
#include "base/threading/sequenced_worker_pool.h"
#include "base/time/time.h"
#include "content/browser/dom_storage/dom_storage_area.h"
#include "content/browser/dom_storage/dom_storage_context_impl.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_namespace.h"
#include "content/public/browser/session_storage_usage_info.h"
#include "content/public/test/mock_special_storage_policy.h"
#include "testing/gtest/include/gtest/gtest.h"
using base::ASCIIToUTF16;
namespace content {
class DOMStorageContextImplTest : public testing::Test {
public:
DOMStorageContextImplTest()
: kOrigin(GURL("http://dom_storage/")),
kKey(ASCIIToUTF16("key")),
kValue(ASCIIToUTF16("value")),
kDontIncludeFileInfo(false),
kDoIncludeFileInfo(true) {
}
const GURL kOrigin;
const base::string16 kKey;
const base::string16 kValue;
const bool kDontIncludeFileInfo;
const bool kDoIncludeFileInfo;
virtual void SetUp() {
ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
storage_policy_ = new MockSpecialStoragePolicy;
task_runner_ =
new MockDOMStorageTaskRunner(base::MessageLoopProxy::current().get());
context_ = new DOMStorageContextImpl(temp_dir_.path(),
base::FilePath(),
storage_policy_.get(),
task_runner_.get());
}
virtual void TearDown() {
base::MessageLoop::current()->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_.path(), base::FilePath(),
NULL, NULL);
std::vector<LocalStorageUsageInfo> infos;
context->GetLocalStorageUsage(&infos, kDontIncludeFileInfo);
ASSERT_EQ(1u, infos.size());
EXPECT_EQ(origin, infos[0].origin);
}
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_.path(), 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;
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));
context_->Shutdown();
context_ = NULL;
base::MessageLoop::current()->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_.path(), base::FilePath(),
NULL, NULL);
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));
EXPECT_TRUE(context_->GetStorageNamespace(kLocalStorageNamespaceId)->
OpenStorageArea(kSessionOnlyOrigin)->SetItem(kKey, kValue, &old_value));
context_->Shutdown();
context_ = NULL;
base::MessageLoop::current()->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));
context_->SetForceKeepSessionState(); // Should override clear behavior.
context_->Shutdown();
context_ = NULL;
base::MessageLoop::current()->RunUntilIdle();
VerifySingleOriginRemains(kSessionOnlyOrigin);
}
TEST_F(DOMStorageContextImplTest, PersistentIds) {
const int kFirstSessionStorageNamespaceId = 1;
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;
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_);
}
TEST_F(DOMStorageContextImplTest, DeleteSessionStorage) {
// Create a DOMStorageContextImpl which will save sessionStorage on disk.
context_ = new DOMStorageContextImpl(temp_dir_.path(),
temp_dir_.path(),
storage_policy_.get(),
task_runner_.get());
context_->SetSaveSessionStorageOnDisk();
ASSERT_EQ(temp_dir_.path(), context_->sessionstorage_directory());
// Write data.
const int kSessionStorageNamespaceId = 1;
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);
dom_namespace->CloseStorageArea(area);
// Destroy and recreate the DOMStorageContextImpl.
context_->Shutdown();
context_ = NULL;
base::MessageLoop::current()->RunUntilIdle();
context_ = new DOMStorageContextImpl(
temp_dir_.path(), temp_dir_.path(),
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;
read_value = area->GetItem(kKey);
EXPECT_EQ(kValue, read_value.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_ = NULL;
base::MessageLoop::current()->RunUntilIdle();
context_ = new DOMStorageContextImpl(
temp_dir_.path(), temp_dir_.path(),
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);
read_value = area->GetItem(kKey);
EXPECT_TRUE(read_value.is_null());
dom_namespace->CloseStorageArea(area);
context_->Shutdown();
context_ = NULL;
base::MessageLoop::current()->RunUntilIdle();
}
TEST_F(DOMStorageContextImplTest, SessionStorageAlias) {
const int kFirstSessionStorageNamespaceId = 1;
const std::string kPersistentId = "persistent";
context_->CreateSessionNamespace(kFirstSessionStorageNamespaceId,
kPersistentId);
DOMStorageNamespace* dom_namespace1 =
context_->GetStorageNamespace(kFirstSessionStorageNamespaceId);
ASSERT_TRUE(dom_namespace1);
DOMStorageArea* area1 = dom_namespace1->OpenStorageArea(kOrigin);
base::NullableString16 old_value;
area1->SetItem(kKey, kValue, &old_value);
EXPECT_TRUE(old_value.is_null());
base::NullableString16 read_value = area1->GetItem(kKey);
EXPECT_TRUE(!read_value.is_null() && read_value.string() == kValue);
// Create an alias.
const int kAliasSessionStorageNamespaceId = 2;
context_->CreateAliasSessionNamespace(kFirstSessionStorageNamespaceId,
kAliasSessionStorageNamespaceId,
kPersistentId);
DOMStorageNamespace* dom_namespace2 =
context_->GetStorageNamespace(kAliasSessionStorageNamespaceId);
ASSERT_TRUE(dom_namespace2);
ASSERT_TRUE(dom_namespace2->alias_master_namespace() == dom_namespace1);
// Verify that read values are identical.
DOMStorageArea* area2 = dom_namespace2->OpenStorageArea(kOrigin);
read_value = area2->GetItem(kKey);
EXPECT_TRUE(!read_value.is_null() && read_value.string() == kValue);
// Verify that writes are reflected in both namespaces.
const base::string16 kValue2(ASCIIToUTF16("value2"));
area2->SetItem(kKey, kValue2, &old_value);
read_value = area1->GetItem(kKey);
EXPECT_TRUE(!read_value.is_null() && read_value.string() == kValue2);
dom_namespace1->CloseStorageArea(area1);
dom_namespace2->CloseStorageArea(area2);
// When creating an alias of an alias, ensure that the master relationship
// is collapsed.
const int kAlias2SessionStorageNamespaceId = 3;
context_->CreateAliasSessionNamespace(kAliasSessionStorageNamespaceId,
kAlias2SessionStorageNamespaceId,
kPersistentId);
DOMStorageNamespace* dom_namespace3 =
context_->GetStorageNamespace(kAlias2SessionStorageNamespaceId);
ASSERT_TRUE(dom_namespace3);
ASSERT_TRUE(dom_namespace3->alias_master_namespace() == dom_namespace1);
}
TEST_F(DOMStorageContextImplTest, SessionStorageMerge) {
// Create a target namespace that we will merge into.
const int kTargetSessionStorageNamespaceId = 1;
const std::string kTargetPersistentId = "persistent";
context_->CreateSessionNamespace(kTargetSessionStorageNamespaceId,
kTargetPersistentId);
DOMStorageNamespace* target_ns =
context_->GetStorageNamespace(kTargetSessionStorageNamespaceId);
ASSERT_TRUE(target_ns);
DOMStorageArea* target_ns_area = target_ns->OpenStorageArea(kOrigin);
base::NullableString16 old_value;
const base::string16 kKey2(ASCIIToUTF16("key2"));
const base::string16 kKey2Value(ASCIIToUTF16("key2value"));
target_ns_area->SetItem(kKey, kValue, &old_value);
target_ns_area->SetItem(kKey2, kKey2Value, &old_value);
// Create a source namespace & its alias.
const int kSourceSessionStorageNamespaceId = 2;
const int kAliasSessionStorageNamespaceId = 3;
const std::string kSourcePersistentId = "persistent_source";
context_->CreateSessionNamespace(kSourceSessionStorageNamespaceId,
kSourcePersistentId);
context_->CreateAliasSessionNamespace(kSourceSessionStorageNamespaceId,
kAliasSessionStorageNamespaceId,
kSourcePersistentId);
DOMStorageNamespace* alias_ns =
context_->GetStorageNamespace(kAliasSessionStorageNamespaceId);
ASSERT_TRUE(alias_ns);
// Create a transaction log that can't be merged.
const int kPid1 = 10;
ASSERT_FALSE(alias_ns->IsLoggingRenderer(kPid1));
alias_ns->AddTransactionLogProcessId(kPid1);
ASSERT_TRUE(alias_ns->IsLoggingRenderer(kPid1));
const base::string16 kValue2(ASCIIToUTF16("value2"));
DOMStorageNamespace::TransactionRecord txn;
txn.origin = kOrigin;
txn.key = kKey;
txn.value = base::NullableString16(kValue2, false);
txn.transaction_type = DOMStorageNamespace::TRANSACTION_READ;
alias_ns->AddTransaction(kPid1, txn);
ASSERT_TRUE(alias_ns->Merge(false, kPid1, target_ns, NULL) ==
SessionStorageNamespace::MERGE_RESULT_NOT_MERGEABLE);
// Create a transaction log that can be merged.
const int kPid2 = 20;
alias_ns->AddTransactionLogProcessId(kPid2);
txn.transaction_type = DOMStorageNamespace::TRANSACTION_WRITE;
alias_ns->AddTransaction(kPid2, txn);
ASSERT_TRUE(alias_ns->Merge(true, kPid2, target_ns, NULL) ==
SessionStorageNamespace::MERGE_RESULT_MERGEABLE);
// Verify that the merge was successful.
ASSERT_TRUE(alias_ns->alias_master_namespace() == target_ns);
base::NullableString16 read_value = target_ns_area->GetItem(kKey);
EXPECT_TRUE(!read_value.is_null() && read_value.string() == kValue2);
DOMStorageArea* alias_ns_area = alias_ns->OpenStorageArea(kOrigin);
read_value = alias_ns_area->GetItem(kKey2);
EXPECT_TRUE(!read_value.is_null() && read_value.string() == kKey2Value);
}
} // namespace content