blob: 973b518a199ea613df176fc8fd084b0b6965f685 [file] [log] [blame]
// Copyright (c) 2012 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 <stdint.h>
#include <utility>
#include "base/files/file_util.h"
#include "base/files/scoped_temp_dir.h"
#include "base/macros.h"
#include "base/memory/ptr_util.h"
#include "base/run_loop.h"
#include "base/threading/sequenced_task_runner_handle.h"
#include "content/browser/indexed_db/indexed_db_connection.h"
#include "content/browser/indexed_db/indexed_db_context_impl.h"
#include "content/browser/indexed_db/indexed_db_factory_impl.h"
#include "content/browser/indexed_db/mock_indexed_db_callbacks.h"
#include "content/browser/indexed_db/mock_indexed_db_database_callbacks.h"
#include "content/public/browser/storage_partition.h"
#include "content/public/common/url_constants.h"
#include "content/public/test/test_browser_thread_bundle.h"
#include "content/public/test/test_utils.h"
#include "storage/browser/quota/quota_manager.h"
#include "storage/browser/quota/special_storage_policy.h"
#include "storage/browser/test/mock_quota_manager_proxy.h"
#include "storage/browser/test/mock_special_storage_policy.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "url/origin.h"
using url::Origin;
namespace content {
class IndexedDBTest : public testing::Test {
public:
const Origin kNormalOrigin;
const Origin kSessionOnlyOrigin;
IndexedDBTest()
: kNormalOrigin(GURL("http://normal/")),
kSessionOnlyOrigin(GURL("http://session-only/")),
special_storage_policy_(
base::MakeRefCounted<MockSpecialStoragePolicy>()),
quota_manager_proxy_(
base::MakeRefCounted<MockQuotaManagerProxy>(nullptr, nullptr)) {
special_storage_policy_->AddSessionOnly(kSessionOnlyOrigin.GetURL());
}
~IndexedDBTest() override {
quota_manager_proxy_->SimulateQuotaManagerDestroyed();
}
protected:
scoped_refptr<MockSpecialStoragePolicy> special_storage_policy_;
scoped_refptr<MockQuotaManagerProxy> quota_manager_proxy_;
private:
TestBrowserThreadBundle thread_bundle_;
DISALLOW_COPY_AND_ASSIGN(IndexedDBTest);
};
TEST_F(IndexedDBTest, ClearSessionOnlyDatabases) {
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
base::FilePath normal_path;
base::FilePath session_only_path;
// Create the scope which will ensure we run the destructor of the context
// which should trigger the clean up.
{
scoped_refptr<IndexedDBContextImpl> idb_context =
base::MakeRefCounted<IndexedDBContextImpl>(
temp_dir.GetPath(), special_storage_policy_.get(),
quota_manager_proxy_.get());
normal_path = idb_context->GetFilePathForTesting(kNormalOrigin);
session_only_path = idb_context->GetFilePathForTesting(kSessionOnlyOrigin);
ASSERT_TRUE(base::CreateDirectory(normal_path));
ASSERT_TRUE(base::CreateDirectory(session_only_path));
RunAllTasksUntilIdle();
quota_manager_proxy_->SimulateQuotaManagerDestroyed();
}
RunAllTasksUntilIdle();
EXPECT_TRUE(base::DirectoryExists(normal_path));
EXPECT_FALSE(base::DirectoryExists(session_only_path));
}
TEST_F(IndexedDBTest, SetForceKeepSessionState) {
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
base::FilePath normal_path;
base::FilePath session_only_path;
// Create the scope which will ensure we run the destructor of the context.
{
// Create some indexedDB paths.
// With the levelDB backend, these are directories.
scoped_refptr<IndexedDBContextImpl> idb_context =
base::MakeRefCounted<IndexedDBContextImpl>(
temp_dir.GetPath(), special_storage_policy_.get(),
quota_manager_proxy_.get());
// Save session state. This should bypass the destruction-time deletion.
idb_context->SetForceKeepSessionState();
normal_path = idb_context->GetFilePathForTesting(kNormalOrigin);
session_only_path = idb_context->GetFilePathForTesting(kSessionOnlyOrigin);
ASSERT_TRUE(base::CreateDirectory(normal_path));
ASSERT_TRUE(base::CreateDirectory(session_only_path));
base::RunLoop().RunUntilIdle();
}
// Make sure we wait until the destructor has run.
base::RunLoop().RunUntilIdle();
// No data was cleared because of SetForceKeepSessionState.
EXPECT_TRUE(base::DirectoryExists(normal_path));
EXPECT_TRUE(base::DirectoryExists(session_only_path));
}
class ForceCloseDBCallbacks : public IndexedDBCallbacks {
public:
ForceCloseDBCallbacks(scoped_refptr<IndexedDBContextImpl> idb_context,
const Origin& origin)
: IndexedDBCallbacks(nullptr, origin, nullptr, idb_context->TaskRunner()),
idb_context_(idb_context),
origin_(origin) {}
void OnSuccess() override {}
void OnSuccess(const std::vector<base::string16>&) override {}
void OnSuccess(std::unique_ptr<IndexedDBConnection> connection,
const IndexedDBDatabaseMetadata& metadata) override {
connection_ = std::move(connection);
idb_context_->ConnectionOpened(origin_, connection_.get());
}
IndexedDBConnection* connection() { return connection_.get(); }
protected:
~ForceCloseDBCallbacks() override {}
private:
scoped_refptr<IndexedDBContextImpl> idb_context_;
Origin origin_;
std::unique_ptr<IndexedDBConnection> connection_;
DISALLOW_COPY_AND_ASSIGN(ForceCloseDBCallbacks);
};
TEST_F(IndexedDBTest, ForceCloseOpenDatabasesOnDelete) {
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
scoped_refptr<IndexedDBContextImpl> idb_context =
base::MakeRefCounted<IndexedDBContextImpl>(temp_dir.GetPath(),
special_storage_policy_.get(),
quota_manager_proxy_.get());
const Origin kTestOrigin(GURL("http://test/"));
idb_context->TaskRunner()->PostTask(
FROM_HERE,
base::BindOnce(
[](IndexedDBContextImpl* idb_context,
scoped_refptr<MockIndexedDBDatabaseCallbacks> open_db_callbacks,
scoped_refptr<MockIndexedDBDatabaseCallbacks> closed_db_callbacks,
scoped_refptr<ForceCloseDBCallbacks> open_callbacks,
scoped_refptr<ForceCloseDBCallbacks> closed_callbacks,
const Origin& origin) {
const int child_process_id = 0;
const int64_t host_transaction_id = 0;
const int64_t version = 0;
const scoped_refptr<net::URLRequestContextGetter> request_context;
IndexedDBFactory* factory = idb_context->GetIDBFactory();
base::FilePath test_path =
idb_context->GetFilePathForTesting(origin);
factory->Open(base::ASCIIToUTF16("opendb"),
base::MakeUnique<IndexedDBPendingConnection>(
open_callbacks, open_db_callbacks,
child_process_id, host_transaction_id, version),
request_context, origin, idb_context->data_path());
EXPECT_TRUE(base::DirectoryExists(test_path));
factory->Open(base::ASCIIToUTF16("closeddb"),
base::MakeUnique<IndexedDBPendingConnection>(
closed_callbacks, closed_db_callbacks,
child_process_id, host_transaction_id, version),
request_context, origin, idb_context->data_path());
closed_callbacks->connection()->Close();
idb_context->DeleteForOrigin(origin);
EXPECT_TRUE(open_db_callbacks->forced_close_called());
EXPECT_FALSE(closed_db_callbacks->forced_close_called());
EXPECT_FALSE(base::DirectoryExists(test_path));
},
base::Unretained(idb_context.get()),
base::MakeRefCounted<MockIndexedDBDatabaseCallbacks>(),
base::MakeRefCounted<MockIndexedDBDatabaseCallbacks>(),
base::MakeRefCounted<ForceCloseDBCallbacks>(idb_context, kTestOrigin),
base::MakeRefCounted<ForceCloseDBCallbacks>(idb_context, kTestOrigin),
kTestOrigin));
RunAllTasksUntilIdle();
}
TEST_F(IndexedDBTest, DeleteFailsIfDirectoryLocked) {
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
const Origin kTestOrigin(GURL("http://test/"));
scoped_refptr<IndexedDBContextImpl> idb_context =
base::MakeRefCounted<IndexedDBContextImpl>(temp_dir.GetPath(),
special_storage_policy_.get(),
quota_manager_proxy_.get());
base::FilePath test_path = idb_context->GetFilePathForTesting(kTestOrigin);
ASSERT_TRUE(base::CreateDirectory(test_path));
std::unique_ptr<LevelDBLock> lock =
LevelDBDatabase::LockForTesting(test_path);
ASSERT_TRUE(lock);
// TODO(jsbell): Remove static_cast<> when overloads are eliminated.
void (IndexedDBContextImpl::* delete_for_origin)(const Origin&) =
&IndexedDBContextImpl::DeleteForOrigin;
idb_context->TaskRunner()->PostTask(
FROM_HERE, base::BindOnce(delete_for_origin, idb_context, kTestOrigin));
RunAllTasksUntilIdle();
EXPECT_TRUE(base::DirectoryExists(test_path));
}
TEST_F(IndexedDBTest, ForceCloseOpenDatabasesOnCommitFailure) {
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
scoped_refptr<IndexedDBContextImpl> idb_context =
base::MakeRefCounted<IndexedDBContextImpl>(temp_dir.GetPath(),
special_storage_policy_.get(),
quota_manager_proxy_.get());
idb_context->TaskRunner()->PostTask(
FROM_HERE,
base::BindOnce(
[](IndexedDBContextImpl* idb_context, const base::FilePath temp_path,
scoped_refptr<MockIndexedDBCallbacks> callbacks,
scoped_refptr<MockIndexedDBDatabaseCallbacks> db_callbacks) {
const Origin kTestOrigin(GURL("http://test/"));
scoped_refptr<IndexedDBFactoryImpl> factory =
static_cast<IndexedDBFactoryImpl*>(
idb_context->GetIDBFactory());
const int child_process_id = 0;
const int64_t transaction_id = 1;
const scoped_refptr<net::URLRequestContextGetter> request_context;
std::unique_ptr<IndexedDBPendingConnection> connection(
base::MakeUnique<IndexedDBPendingConnection>(
callbacks, db_callbacks, child_process_id, transaction_id,
IndexedDBDatabaseMetadata::DEFAULT_VERSION));
factory->Open(base::ASCIIToUTF16("db"), std::move(connection),
request_context, Origin(kTestOrigin), temp_path);
EXPECT_TRUE(callbacks->connection());
// ConnectionOpened() is usually called by the dispatcher.
idb_context->ConnectionOpened(kTestOrigin, callbacks->connection());
EXPECT_TRUE(factory->IsBackingStoreOpen(kTestOrigin));
// Simulate the write failure.
leveldb::Status status =
leveldb::Status::IOError("Simulated failure");
idb_context->GetIDBFactory()->HandleBackingStoreFailure(
kTestOrigin);
EXPECT_TRUE(db_callbacks->forced_close_called());
EXPECT_FALSE(factory->IsBackingStoreOpen(kTestOrigin));
},
base::Unretained(idb_context.get()), temp_dir.GetPath(),
base::MakeRefCounted<MockIndexedDBCallbacks>(),
base::MakeRefCounted<MockIndexedDBDatabaseCallbacks>()));
RunAllTasksUntilIdle();
}
} // namespace content