From 33299a9ba6a3ead1b0ff1e1bfe9dd8d4ee961d8b Mon Sep 17 00:00:00 2001 From: erg Date: Thu, 18 Feb 2016 10:47:16 -0800 Subject: mojo: Remove the mojo:filesystem sqlite binding code. As the performance isn't great, and since we need to make changes to how mojo:filesystem works to integrate with chrome in general, drop the two previous users of mojo:filesystem: the mojo:network_service cookie store and the underlying sqlite bridge code. BUG=585587 Review URL: https://codereview.chromium.org/1710693002 Cr-Commit-Position: refs/heads/master@{#376212} --- sql/mojo/BUILD.gn | 62 ------- sql/mojo/DEPS | 6 - sql/mojo/mojo_vfs.cc | 455 ---------------------------------------------- sql/mojo/mojo_vfs.h | 45 ----- sql/mojo/sql_test_base.cc | 164 ----------------- sql/mojo/sql_test_base.h | 92 ---------- sql/mojo/vfs_unittest.cc | 340 ---------------------------------- 7 files changed, 1164 deletions(-) delete mode 100644 sql/mojo/BUILD.gn delete mode 100644 sql/mojo/DEPS delete mode 100644 sql/mojo/mojo_vfs.cc delete mode 100644 sql/mojo/mojo_vfs.h delete mode 100644 sql/mojo/sql_test_base.cc delete mode 100644 sql/mojo/sql_test_base.h delete mode 100644 sql/mojo/vfs_unittest.cc (limited to 'sql') diff --git a/sql/mojo/BUILD.gn b/sql/mojo/BUILD.gn deleted file mode 100644 index b7a3793..0000000 --- a/sql/mojo/BUILD.gn +++ /dev/null @@ -1,62 +0,0 @@ -# Copyright 2015 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. - -import("//mojo/public/mojo_application.gni") - -source_set("mojo") { - sources = [ - "mojo_vfs.cc", - "mojo_vfs.h", - ] - - # TODO(jschuh): crbug.com/167187 fix size_t to int truncations. - configs += [ "//build/config/compiler:no_size_t_to_int_warning" ] - - defines = [ "SQL_IMPLEMENTATION" ] - - deps = [ - "//base", - "//base/third_party/dynamic_annotations", - "//components/filesystem/public/interfaces", - "//mojo/common", - "//mojo/platform_handle", - "//mojo/shell/public/cpp", - "//third_party/sqlite", - ] -} - -mojo_native_application("apptests") { - output_name = "sql_apptests" - - testonly = true - - # Instead of using the code in //sql/test/sql_test_base.h, we should use the - # mojo test base class. - defines = [ "MOJO_APPTEST_IMPL" ] - - sources = [ - "../connection_unittest.cc", - "../statement_unittest.cc", - "../test/paths.cc", - "../test/paths.h", - "../transaction_unittest.cc", - "sql_test_base.cc", - "sql_test_base.h", - "vfs_unittest.cc", - ] - - deps = [ - ":mojo", - "//base", - "//base/test:test_support", - "//components/filesystem/public/interfaces", - "//mojo/public/cpp/bindings", - "//mojo/shell/public/cpp:sources", - "//mojo/shell/public/cpp:test_support", - "//sql", - "//sql:redirection_header", - "//sql:test_support", - "//testing/gtest:gtest", - ] -} diff --git a/sql/mojo/DEPS b/sql/mojo/DEPS deleted file mode 100644 index 9dd7c02..0000000 --- a/sql/mojo/DEPS +++ /dev/null @@ -1,6 +0,0 @@ -include_rules = [ - "+components/filesystem", - "+mojo/shell", - "+mojo/public", - "+mojo/util", -] diff --git a/sql/mojo/mojo_vfs.cc b/sql/mojo/mojo_vfs.cc deleted file mode 100644 index bd962d0..0000000 --- a/sql/mojo/mojo_vfs.cc +++ /dev/null @@ -1,455 +0,0 @@ -// Copyright 2015 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 "sql/mojo/mojo_vfs.h" - -#include -#include -#include - -#include "base/logging.h" -#include "base/rand_util.h" -#include "base/strings/stringprintf.h" -#include "base/trace_event/trace_event.h" -#include "components/filesystem/public/interfaces/file.mojom.h" -#include "components/filesystem/public/interfaces/file_system.mojom.h" -#include "components/filesystem/public/interfaces/types.mojom.h" -#include "mojo/public/cpp/bindings/lib/template_util.h" -#include "mojo/util/capture_util.h" -#include "third_party/sqlite/sqlite3.h" - -using mojo::Capture; - -namespace sql { - -sqlite3_vfs* GetParentVFS(sqlite3_vfs* mojo_vfs) { - return static_cast(mojo_vfs->pAppData)->parent_; -} - -filesystem::DirectoryPtr& GetRootDirectory(sqlite3_vfs* mojo_vfs) { - return static_cast(mojo_vfs->pAppData)-> - root_directory_; -} - -namespace { - -// Implementation of the sqlite3 Mojo proxying vfs. -// -// This is a bunch of C callback objects which transparently proxy sqlite3's -// filesystem reads/writes over the mojo:filesystem service. The main -// entrypoint is sqlite3_mojovfs(), which proxies all the file open/delete/etc -// operations. mojo:filesystem has support for passing a raw file descriptor -// over the IPC barrier, and most of the implementation of sqlite3_io_methods -// is derived from the default sqlite3 unix VFS and operates on the raw file -// descriptors. - -const int kMaxPathName = 512; - -// A struct which extends the base sqlite3_file to also hold on to a file -// pipe. We reinterpret_cast our sqlite3_file structs to this struct -// instead. This is "safe" because this struct is really just a slab of -// malloced memory, of which we tell sqlite how large we want with szOsFile. -struct MojoVFSFile { - // The "vtable" of our sqlite3_file "subclass". - sqlite3_file base; - - // We keep an open pipe to the File object to keep it from cleaning itself - // up. - filesystem::FilePtr file_ptr; -}; - -filesystem::FilePtr& GetFSFile(sqlite3_file* vfs_file) { - return reinterpret_cast(vfs_file)->file_ptr; -} - -int MojoVFSClose(sqlite3_file* file) { - DVLOG(1) << "MojoVFSClose(*)"; - TRACE_EVENT0("sql", "MojoVFSClose"); - using filesystem::FilePtr; - filesystem::FileError error = filesystem::FileError::FAILED; - // Must call File::Close explicitly instead of just deleting the file, since - // otherwise we wouldn't have an object to wait on. - GetFSFile(file)->Close(mojo::Capture(&error)); - GetFSFile(file).WaitForIncomingResponse(); - GetFSFile(file).~FilePtr(); - return SQLITE_OK; -} - -int MojoVFSRead(sqlite3_file* sql_file, - void* buffer, - int size, - sqlite3_int64 offset) { - DVLOG(1) << "MojoVFSRead (" << size << " @ " << offset << ")"; - TRACE_EVENT0("sql", "MojoVFSRead"); - filesystem::FileError error = filesystem::FileError::FAILED; - mojo::Array mojo_data; - GetFSFile(sql_file)->Read(size, offset, filesystem::Whence::FROM_BEGIN, - Capture(&error, &mojo_data)); - GetFSFile(sql_file).WaitForIncomingResponse(); - - if (error != filesystem::FileError::OK) { - // TODO(erg): Better implementation here. - NOTIMPLEMENTED(); - return SQLITE_IOERR_READ; - } - - if (mojo_data.size()) - memcpy(buffer, &mojo_data.front(), mojo_data.size()); - if (mojo_data.size() == static_cast(size)) - return SQLITE_OK; - - // We didn't read the entire buffer. Fill the rest of the buffer with zeros. - memset(reinterpret_cast(buffer) + mojo_data.size(), 0, - size - mojo_data.size()); - - return SQLITE_IOERR_SHORT_READ; -} - -int MojoVFSWrite(sqlite3_file* sql_file, - const void* buffer, - int size, - sqlite_int64 offset) { - DVLOG(1) << "MojoVFSWrite(*, " << size << ", " << offset << ")"; - TRACE_EVENT0("sql", "MojoVFSWrite"); - mojo::Array mojo_data(size); - memcpy(&mojo_data.front(), buffer, size); - - filesystem::FileError error = filesystem::FileError::FAILED; - uint32_t num_bytes_written = 0; - GetFSFile(sql_file)->Write(std::move(mojo_data), offset, - filesystem::Whence::FROM_BEGIN, - Capture(&error, &num_bytes_written)); - GetFSFile(sql_file).WaitForIncomingResponse(); - if (error != filesystem::FileError::OK) { - // TODO(erg): Better implementation here. - NOTIMPLEMENTED(); - return SQLITE_IOERR_WRITE; - } - if (num_bytes_written != static_cast(size)) { - NOTIMPLEMENTED(); - return SQLITE_IOERR_WRITE; - } - - return SQLITE_OK; -} - -int MojoVFSTruncate(sqlite3_file* sql_file, sqlite_int64 size) { - DVLOG(1) << "MojoVFSTruncate(*, " << size << ")"; - TRACE_EVENT0("sql", "MojoVFSTruncate"); - filesystem::FileError error = filesystem::FileError::FAILED; - GetFSFile(sql_file)->Truncate(size, Capture(&error)); - GetFSFile(sql_file).WaitForIncomingResponse(); - if (error != filesystem::FileError::OK) { - // TODO(erg): Better implementation here. - NOTIMPLEMENTED(); - return SQLITE_IOERR_TRUNCATE; - } - - return SQLITE_OK; -} - -int MojoVFSSync(sqlite3_file* sql_file, int flags) { - DVLOG(1) << "MojoVFSSync(*, " << flags << ")"; - TRACE_EVENT0("sql", "MojoVFSSync"); - filesystem::FileError error = filesystem::FileError::FAILED; - GetFSFile(sql_file)->Flush(Capture(&error)); - GetFSFile(sql_file).WaitForIncomingResponse(); - if (error != filesystem::FileError::OK) { - // TODO(erg): Better implementation here. - NOTIMPLEMENTED(); - return SQLITE_IOERR_FSYNC; - } - - return SQLITE_OK; -} - -int MojoVFSFileSize(sqlite3_file* sql_file, sqlite_int64* size) { - DVLOG(1) << "MojoVFSFileSize(*)"; - TRACE_EVENT0("sql", "MojoVFSFileSize"); - - filesystem::FileError err = filesystem::FileError::FAILED; - filesystem::FileInformationPtr file_info; - GetFSFile(sql_file)->Stat(Capture(&err, &file_info)); - GetFSFile(sql_file).WaitForIncomingResponse(); - - if (err != filesystem::FileError::OK) { - // TODO(erg): Better implementation here. - NOTIMPLEMENTED(); - return SQLITE_IOERR_FSTAT; - } - - *size = file_info->size; - return SQLITE_OK; -} - -// TODO(erg): The current base::File interface isn't sufficient to handle -// sqlite's locking primitives, which are done on byte ranges in the file. (See -// "File Locking Notes" in sqlite3.c.) -int MojoVFSLock(sqlite3_file* pFile, int eLock) { - DVLOG(1) << "MojoVFSLock(*, " << eLock << ")"; - return SQLITE_OK; -} -int MojoVFSUnlock(sqlite3_file* pFile, int eLock) { - DVLOG(1) << "MojoVFSUnlock(*, " << eLock << ")"; - return SQLITE_OK; -} -int MojoVFSCheckReservedLock(sqlite3_file* pFile, int* pResOut) { - DVLOG(1) << "MojoVFSCheckReservedLock(*)"; - *pResOut = 0; - return SQLITE_OK; -} - -// TODO(erg): This is the minimal implementation to get a few tests passing; -// lots more needs to be done here. -int MojoVFSFileControl(sqlite3_file* pFile, int op, void* pArg) { - DVLOG(1) << "MojoVFSFileControl(*, " << op << ", *)"; - if (op == SQLITE_FCNTL_PRAGMA) { - // Returning NOTFOUND tells sqlite that we aren't doing any processing. - return SQLITE_NOTFOUND; - } - - return SQLITE_OK; -} - -int MojoVFSSectorSize(sqlite3_file* pFile) { - DVLOG(1) << "MojoVFSSectorSize(*)"; - // Use the default sector size. - return 0; -} - -int MojoVFSDeviceCharacteristics(sqlite3_file* pFile) { - DVLOG(1) << "MojoVFSDeviceCharacteristics(*)"; - // TODO(erg): Figure out what to return here. (This function is super spammy, - // so not leaving a NOTIMPLEMENTED().) - return 0; -} - -static sqlite3_io_methods mojo_vfs_io_methods = { - 1, /* iVersion */ - MojoVFSClose, /* xClose */ - MojoVFSRead, /* xRead */ - MojoVFSWrite, /* xWrite */ - MojoVFSTruncate, /* xTruncate */ - MojoVFSSync, /* xSync */ - MojoVFSFileSize, /* xFileSize */ - MojoVFSLock, /* xLock */ - MojoVFSUnlock, /* xUnlock */ - MojoVFSCheckReservedLock, /* xCheckReservedLock */ - MojoVFSFileControl, /* xFileControl */ - MojoVFSSectorSize, /* xSectorSize */ - MojoVFSDeviceCharacteristics, /* xDeviceCharacteristics */ -}; - -int MojoVFSOpen(sqlite3_vfs* mojo_vfs, - const char* name, - sqlite3_file* file, - int flags, - int* pOutFlags) { - DVLOG(1) << "MojoVFSOpen(*, " << name << ", *, " << flags << ")"; - TRACE_EVENT2("sql", "MojoVFSOpen", - "name", name, - "flags", flags); - int open_flags = 0; - if (flags & SQLITE_OPEN_EXCLUSIVE) { - DCHECK(flags & SQLITE_OPEN_CREATE); - open_flags = filesystem::kFlagCreate; - } else if (flags & SQLITE_OPEN_CREATE) { - DCHECK(flags & SQLITE_OPEN_READWRITE); - open_flags = filesystem::kFlagOpenAlways; - } else { - open_flags = filesystem::kFlagOpen; - } - open_flags |= filesystem::kFlagRead; - if (flags & SQLITE_OPEN_READWRITE) - open_flags |= filesystem::kFlagWrite; - if (flags & SQLITE_OPEN_DELETEONCLOSE) - open_flags |= filesystem::kDeleteOnClose; - - mojo::String mojo_name; - if (name) { - // Don't let callers open the pattern of our temporary databases. When we - // open with a null name and SQLITE_OPEN_DELETEONCLOSE, we unlink the - // database after we open it. If we create a database here, close it - // normally, and then open the same file through the other path, we could - // delete the database. - CHECK(strncmp("Temp_", name, 5) != 0); - mojo_name = name; - } else { - DCHECK(flags & SQLITE_OPEN_DELETEONCLOSE); - static int temp_number = 0; - mojo_name = base::StringPrintf("Temp_%d.db", temp_number++); - } - - // Grab the incoming file - filesystem::FilePtr file_ptr; - filesystem::FileError error = filesystem::FileError::FAILED; - GetRootDirectory(mojo_vfs)->OpenFile(mojo_name, GetProxy(&file_ptr), - open_flags, Capture(&error)); - GetRootDirectory(mojo_vfs).WaitForIncomingResponse(); - if (error != filesystem::FileError::OK) { - // TODO(erg): Translate more of the mojo error codes into sqlite error - // codes. - return SQLITE_CANTOPEN; - } - - // Set the method table so we can be closed (and run the manual dtor call to - // match the following placement news). - file->pMethods = &mojo_vfs_io_methods; - - // |file| is actually a malloced buffer of size szOsFile. This means that we - // need to manually use placement new to construct the C++ object which owns - // the pipe to our file. - new (&GetFSFile(file)) filesystem::FilePtr(std::move(file_ptr)); - - return SQLITE_OK; -} - -int MojoVFSDelete(sqlite3_vfs* mojo_vfs, const char* filename, int sync_dir) { - DVLOG(1) << "MojoVFSDelete(*, " << filename << ", " << sync_dir << ")"; - TRACE_EVENT2("sql", "MojoVFSDelete", - "name", filename, - "sync_dir", sync_dir); - // TODO(erg): The default windows sqlite VFS has retry code to work around - // antivirus software keeping files open. We'll probably have to do something - // like that in the far future if we ever support Windows. - filesystem::FileError error = filesystem::FileError::FAILED; - GetRootDirectory(mojo_vfs)->Delete(filename, 0, Capture(&error)); - GetRootDirectory(mojo_vfs).WaitForIncomingResponse(); - - if (error == filesystem::FileError::OK && sync_dir) { - GetRootDirectory(mojo_vfs)->Flush(Capture(&error)); - GetRootDirectory(mojo_vfs).WaitForIncomingResponse(); - } - - return error == filesystem::FileError::OK ? SQLITE_OK : SQLITE_IOERR_DELETE; -} - -int MojoVFSAccess(sqlite3_vfs* mojo_vfs, - const char* filename, - int flags, - int* result) { - DVLOG(1) << "MojoVFSAccess(*, " << filename << ", " << flags << ", *)"; - TRACE_EVENT2("sql", "MojoVFSAccess", - "name", filename, - "flags", flags); - filesystem::FileError error = filesystem::FileError::FAILED; - - if (flags == SQLITE_ACCESS_READWRITE || flags == SQLITE_ACCESS_READ) { - bool is_writable = false; - GetRootDirectory(mojo_vfs) - ->IsWritable(filename, Capture(&error, &is_writable)); - GetRootDirectory(mojo_vfs).WaitForIncomingResponse(); - *result = is_writable; - return SQLITE_OK; - } - - if (flags == SQLITE_ACCESS_EXISTS) { - bool exists = false; - GetRootDirectory(mojo_vfs)->Exists(filename, Capture(&error, &exists)); - GetRootDirectory(mojo_vfs).WaitForIncomingResponse(); - *result = exists; - return SQLITE_OK; - } - - return SQLITE_IOERR; -} - -int MojoVFSFullPathname(sqlite3_vfs* mojo_vfs, - const char* relative_path, - int absolute_path_size, - char* absolute_path) { - // The sandboxed process doesn't need to know the absolute path of the file. - sqlite3_snprintf(absolute_path_size, absolute_path, "%s", relative_path); - return SQLITE_OK; -} - -// Don't let SQLite dynamically load things. (If we are using the -// mojo:filesystem proxying VFS, then it's highly likely that we are sandboxed -// and that any attempt to dlopen() a shared object is folly.) -void* MojoVFSDlOpen(sqlite3_vfs*, const char*) { - return 0; -} - -void MojoVFSDlError(sqlite3_vfs*, int buf_size, char* error_msg) { - sqlite3_snprintf(buf_size, error_msg, "Dynamic loading not supported"); -} - -void (*MojoVFSDlSym(sqlite3_vfs*, void*, const char*))(void) { - return 0; -} - -void MojoVFSDlClose(sqlite3_vfs*, void*) { - return; -} - -int MojoVFSRandomness(sqlite3_vfs* mojo_vfs, int size, char* out) { - base::RandBytes(out, size); - return size; -} - -// Proxy the rest of the calls down to the OS specific handler. -int MojoVFSSleep(sqlite3_vfs* mojo_vfs, int micro) { - return GetParentVFS(mojo_vfs)->xSleep(GetParentVFS(mojo_vfs), micro); -} - -int MojoVFSCurrentTime(sqlite3_vfs* mojo_vfs, double* time) { - return GetParentVFS(mojo_vfs)->xCurrentTime(GetParentVFS(mojo_vfs), time); -} - -int MojoVFSGetLastError(sqlite3_vfs* mojo_vfs, int a, char* b) { - return 0; -} - -int MojoVFSCurrentTimeInt64(sqlite3_vfs* mojo_vfs, sqlite3_int64* out) { - return GetParentVFS(mojo_vfs)->xCurrentTimeInt64(GetParentVFS(mojo_vfs), out); -} - -static sqlite3_vfs mojo_vfs = { - 1, /* iVersion */ - sizeof(MojoVFSFile), /* szOsFile */ - kMaxPathName, /* mxPathname */ - 0, /* pNext */ - "mojo", /* zName */ - 0, /* pAppData */ - MojoVFSOpen, /* xOpen */ - MojoVFSDelete, /* xDelete */ - MojoVFSAccess, /* xAccess */ - MojoVFSFullPathname, /* xFullPathname */ - MojoVFSDlOpen, /* xDlOpen */ - MojoVFSDlError, /* xDlError */ - MojoVFSDlSym, /* xDlSym */ - MojoVFSDlClose, /* xDlClose */ - MojoVFSRandomness, /* xRandomness */ - MojoVFSSleep, /* xSleep */ - MojoVFSCurrentTime, /* xCurrentTime */ - MojoVFSGetLastError, /* xGetLastError */ - MojoVFSCurrentTimeInt64 /* xCurrentTimeInt64 */ -}; - -} // namespace - -ScopedMojoFilesystemVFS::ScopedMojoFilesystemVFS( - filesystem::DirectoryPtr root_directory) - : parent_(sqlite3_vfs_find(NULL)), - root_directory_(std::move(root_directory)) { - CHECK(!mojo_vfs.pAppData); - mojo_vfs.pAppData = this; - mojo_vfs.mxPathname = parent_->mxPathname; - - CHECK(sqlite3_vfs_register(&mojo_vfs, 1) == SQLITE_OK); -} - -ScopedMojoFilesystemVFS::~ScopedMojoFilesystemVFS() { - CHECK(mojo_vfs.pAppData); - mojo_vfs.pAppData = nullptr; - - CHECK(sqlite3_vfs_register(parent_, 1) == SQLITE_OK); - CHECK(sqlite3_vfs_unregister(&mojo_vfs) == SQLITE_OK); -} - -filesystem::DirectoryPtr& ScopedMojoFilesystemVFS::GetDirectory() { - return root_directory_; -} - -} // namespace sql diff --git a/sql/mojo/mojo_vfs.h b/sql/mojo/mojo_vfs.h deleted file mode 100644 index dc83593..0000000 --- a/sql/mojo/mojo_vfs.h +++ /dev/null @@ -1,45 +0,0 @@ -// Copyright 2015 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. - -#ifndef SQL_MOJO_MOJO_VFS_H_ -#define SQL_MOJO_MOJO_VFS_H_ - -#include "base/macros.h" -#include "components/filesystem/public/interfaces/directory.mojom.h" - -typedef struct sqlite3_vfs sqlite3_vfs; - -namespace sql { - -// Changes the default sqlite3 vfs to a vfs that uses proxies calls to the -// mojo:filesystem service. Instantiating this object transparently changes how -// the entire //sql/ subsystem works in the process of the caller; all paths -// are treated as relative to |directory|. -class ScopedMojoFilesystemVFS { - public: - explicit ScopedMojoFilesystemVFS(filesystem::DirectoryPtr directory); - ~ScopedMojoFilesystemVFS(); - - // Returns the directory of the current VFS. - filesystem::DirectoryPtr& GetDirectory(); - - private: - friend sqlite3_vfs* GetParentVFS(sqlite3_vfs* mojo_vfs); - friend filesystem::DirectoryPtr& GetRootDirectory(sqlite3_vfs* mojo_vfs); - - // The default vfs at the time MojoVFS was installed. We use the to pass - // through things like randomness requests and per-platform sleep calls. - sqlite3_vfs* parent_; - - // When we initialize the subsystem, we are given a filesystem::Directory - // object, which is the root directory of a mojo:filesystem. All access to - // various files are specified from this root directory. - filesystem::DirectoryPtr root_directory_; - - DISALLOW_COPY_AND_ASSIGN(ScopedMojoFilesystemVFS); -}; - -} // namespace sql - -#endif // SQL_MOJO_MOJO_VFS_H_ diff --git a/sql/mojo/sql_test_base.cc b/sql/mojo/sql_test_base.cc deleted file mode 100644 index baecd04..0000000 --- a/sql/mojo/sql_test_base.cc +++ /dev/null @@ -1,164 +0,0 @@ -// Copyright 2015 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 "sql/mojo/sql_test_base.h" - -#include -#include -#include - -#include "mojo/shell/public/cpp/shell.h" -#include "mojo/util/capture_util.h" -#include "sql/mojo/mojo_vfs.h" -#include "sql/test/test_helpers.h" - -using mojo::Capture; - -namespace sql { - -SQLTestBase::SQLTestBase() - : binding_(this) { -} - -SQLTestBase::~SQLTestBase() { -} - -base::FilePath SQLTestBase::db_path() { - return base::FilePath(FILE_PATH_LITERAL("SQLTest.db")); -} - -sql::Connection& SQLTestBase::db() { - return db_; -} - -bool SQLTestBase::Reopen() { - db_.Close(); - return db_.Open(db_path()); -} - -bool SQLTestBase::GetPathExists(const base::FilePath& path) { - filesystem::FileError error = filesystem::FileError::FAILED; - bool exists = false; - vfs_->GetDirectory()->Exists(path.AsUTF8Unsafe(), Capture(&error, &exists)); - vfs_->GetDirectory().WaitForIncomingResponse(); - if (error != filesystem::FileError::OK) - return false; - return exists; -} - -bool SQLTestBase::CorruptSizeInHeaderOfDB() { - // See http://www.sqlite.org/fileformat.html#database_header - const size_t kHeaderSize = 100; - - mojo::Array header; - - filesystem::FileError error = filesystem::FileError::FAILED; - filesystem::FilePtr file_ptr; - vfs_->GetDirectory()->OpenFile( - mojo::String(db_path().AsUTF8Unsafe()), GetProxy(&file_ptr), - filesystem::kFlagRead | filesystem::kFlagWrite | - filesystem::kFlagOpenAlways, - Capture(&error)); - vfs_->GetDirectory().WaitForIncomingResponse(); - if (error != filesystem::FileError::OK) - return false; - - file_ptr->Read(kHeaderSize, 0, filesystem::Whence::FROM_BEGIN, - Capture(&error, &header)); - file_ptr.WaitForIncomingResponse(); - if (error != filesystem::FileError::OK) - return false; - - filesystem::FileInformationPtr info; - file_ptr->Stat(Capture(&error, &info)); - file_ptr.WaitForIncomingResponse(); - if (error != filesystem::FileError::OK) - return false; - int64_t db_size = info->size; - - test::CorruptSizeInHeaderMemory(&header.front(), db_size); - - uint32_t num_bytes_written = 0; - file_ptr->Write(std::move(header), 0, filesystem::Whence::FROM_BEGIN, - Capture(&error, &num_bytes_written)); - file_ptr.WaitForIncomingResponse(); - if (error != filesystem::FileError::OK) - return false; - if (num_bytes_written != kHeaderSize) - return false; - - return true; -} - -void SQLTestBase::WriteJunkToDatabase(WriteJunkType type) { - uint32_t flags = 0; - if (type == TYPE_OVERWRITE_AND_TRUNCATE) - flags = filesystem::kFlagWrite | filesystem::kFlagCreate; - else - flags = filesystem::kFlagWrite | filesystem::kFlagOpen; - - filesystem::FileError error = filesystem::FileError::FAILED; - filesystem::FilePtr file_ptr; - vfs_->GetDirectory()->OpenFile( - mojo::String(db_path().AsUTF8Unsafe()), GetProxy(&file_ptr), - flags, - Capture(&error)); - vfs_->GetDirectory().WaitForIncomingResponse(); - if (error != filesystem::FileError::OK) - return; - - const char* kJunk = "Now is the winter of our discontent."; - mojo::Array data(strlen(kJunk)); - memcpy(&data.front(), kJunk, strlen(kJunk)); - - uint32_t num_bytes_written = 0; - file_ptr->Write(std::move(data), 0, filesystem::Whence::FROM_BEGIN, - Capture(&error, &num_bytes_written)); - file_ptr.WaitForIncomingResponse(); -} - -void SQLTestBase::TruncateDatabase() { - filesystem::FileError error = filesystem::FileError::FAILED; - filesystem::FilePtr file_ptr; - vfs_->GetDirectory()->OpenFile( - mojo::String(db_path().AsUTF8Unsafe()), GetProxy(&file_ptr), - filesystem::kFlagWrite | filesystem::kFlagOpen, - Capture(&error)); - vfs_->GetDirectory().WaitForIncomingResponse(); - if (error != filesystem::FileError::OK) - return; - - file_ptr->Truncate(0, Capture(&error)); - file_ptr.WaitForIncomingResponse(); - ASSERT_EQ(filesystem::FileError::OK, error); -} - -void SQLTestBase::SetUp() { - ApplicationTestBase::SetUp(); - - shell()->ConnectToInterface("mojo:filesystem", &files_); - - filesystem::FileError error = filesystem::FileError::FAILED; - filesystem::DirectoryPtr directory; - files()->OpenFileSystem("temp", GetProxy(&directory), - binding_.CreateInterfacePtrAndBind(), - Capture(&error)); - ASSERT_TRUE(files().WaitForIncomingResponse()); - ASSERT_EQ(filesystem::FileError::OK, error); - - vfs_.reset(new ScopedMojoFilesystemVFS(std::move(directory))); - ASSERT_TRUE(db_.Open(db_path())); -} - -void SQLTestBase::TearDown() { - db_.Close(); - vfs_.reset(); - - ApplicationTestBase::TearDown(); -} - -void SQLTestBase::OnFileSystemShutdown() { -} - -} // namespace sql diff --git a/sql/mojo/sql_test_base.h b/sql/mojo/sql_test_base.h deleted file mode 100644 index 2fba5aa..0000000 --- a/sql/mojo/sql_test_base.h +++ /dev/null @@ -1,92 +0,0 @@ -// Copyright 2015 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. - -#ifndef SQL_MOJO_SQL_TEST_BASE_H_ -#define SQL_MOJO_SQL_TEST_BASE_H_ - -#include "base/files/file_path.h" -#include "base/macros.h" -#include "base/memory/scoped_ptr.h" -#include "components/filesystem/public/interfaces/file_system.mojom.h" -#include "mojo/public/cpp/bindings/binding.h" -#include "mojo/shell/public/cpp/application_test_base.h" -#include "sql/connection.h" -#include "testing/gtest/include/gtest/gtest.h" - -namespace sql { - -class Connection; -class ScopedMojoFilesystemVFS; - -// Base class for SQL tests. -// -// WARNING: We want to run the same gtest based unit test code both against -// chromium (which uses this implementation here), and the mojo code (which -// uses a different class named SQLTestBase). These two classes need to have -// the same interface because we compile time switch them based on a -// #define. We need to have two different implementations because the mojo -// version derives from mojo::test::ApplicationTestBase instead of -// testing::Test. -class SQLTestBase : public mojo::test::ApplicationTestBase, - public filesystem::FileSystemClient { - public: - SQLTestBase(); - ~SQLTestBase() override; - - enum WriteJunkType { - TYPE_OVERWRITE_AND_TRUNCATE, - TYPE_OVERWRITE - }; - - // Returns the path to the database. - base::FilePath db_path(); - - // Returns a connection to the database at db_path(). - sql::Connection& db(); - - // Closes the current connection to the database and reopens it. - bool Reopen(); - - // Proxying method around base::PathExists. - bool GetPathExists(const base::FilePath& path); - - // SQLite stores the database size in the header, and if the actual - // OS-derived size is smaller, the database is considered corrupt. - // [This case is actually a common form of corruption in the wild.] - // This helper sets the in-header size to one page larger than the - // actual file size. The resulting file will return SQLITE_CORRUPT - // for most operations unless PRAGMA writable_schema is turned ON. - // - // Returns false if any error occurs accessing the file. - bool CorruptSizeInHeaderOfDB(); - - // Writes junk to the start of the file. - void WriteJunkToDatabase(WriteJunkType type); - - // Sets the database file size to 0. - void TruncateDatabase(); - - // Overridden from testing::Test: - void SetUp() override; - void TearDown() override; - - // Overridden from FileSystemClient: - void OnFileSystemShutdown() override; - - protected: - filesystem::FileSystemPtr& files() { return files_; } - - private: - filesystem::FileSystemPtr files_; - - scoped_ptr vfs_; - mojo::Binding binding_; - sql::Connection db_; - - DISALLOW_COPY_AND_ASSIGN(SQLTestBase); -}; - -} // namespace sql - -#endif // SQL_MOJO_SQL_TEST_BASE_H_ diff --git a/sql/mojo/vfs_unittest.cc b/sql/mojo/vfs_unittest.cc deleted file mode 100644 index 395f7ba..0000000 --- a/sql/mojo/vfs_unittest.cc +++ /dev/null @@ -1,340 +0,0 @@ -// Copyright 2015 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 -#include -#include - -#include "base/macros.h" -#include "components/filesystem/public/interfaces/file_system.mojom.h" -#include "mojo/shell/public/cpp/application_test_base.h" -#include "mojo/shell/public/cpp/shell.h" -#include "mojo/util/capture_util.h" -#include "sql/mojo/mojo_vfs.h" -#include "testing/gtest/include/gtest/gtest.h" -#include "third_party/sqlite/sqlite3.h" - -namespace std { - -// This deleter lets us be safe with sqlite3 objects, which aren't really the -// structs, but slabs of new uint8_t[size]. -template <> -struct default_delete { - inline void operator()(sqlite3_file* ptr) const { - // Why don't we call file->pMethods->xClose() here? Because it's not - // guaranteed to be valid. sqlite3_file "objects" can be in partially - // initialized states. - delete [] reinterpret_cast(ptr); - } -}; - -} // namespace std - -namespace sql { - -const char kFileName[] = "TestingDatabase.db"; - -class VFSTest : public mojo::test::ApplicationTestBase, - public filesystem::FileSystemClient { - public: - VFSTest() : binding_(this) {} - ~VFSTest() override {} - - sqlite3_vfs* vfs() { - return sqlite3_vfs_find(NULL); - } - - scoped_ptr MakeFile() { - return scoped_ptr(reinterpret_cast( - new uint8_t[vfs()->szOsFile])); - } - - void SetUp() override { - mojo::test::ApplicationTestBase::SetUp(); - - shell()->ConnectToInterface("mojo:filesystem", &files_); - - filesystem::FileError error = filesystem::FileError::FAILED; - filesystem::DirectoryPtr directory; - files_->OpenFileSystem("temp", GetProxy(&directory), - binding_.CreateInterfacePtrAndBind(), - mojo::Capture(&error)); - ASSERT_TRUE(files_.WaitForIncomingResponse()); - ASSERT_EQ(filesystem::FileError::OK, error); - - vfs_.reset(new ScopedMojoFilesystemVFS(std::move(directory))); - } - - void TearDown() override { - vfs_.reset(); - mojo::test::ApplicationTestBase::TearDown(); - } - - void OnFileSystemShutdown() override { - } - - private: - filesystem::FileSystemPtr files_; - scoped_ptr vfs_; - mojo::Binding binding_; - - DISALLOW_COPY_AND_ASSIGN(VFSTest); -}; - -TEST_F(VFSTest, TestInstalled) { - EXPECT_EQ("mojo", std::string(vfs()->zName)); -} - -TEST_F(VFSTest, ExclusiveOpen) { - // Opening a non-existent file exclusively should work. - scoped_ptr file(MakeFile()); - int out_flags; - int rc = vfs()->xOpen(vfs(), kFileName, file.get(), - SQLITE_OPEN_EXCLUSIVE | SQLITE_OPEN_CREATE, - &out_flags); - EXPECT_EQ(SQLITE_OK, rc); - - // Opening it a second time exclusively shouldn't. - scoped_ptr file2(MakeFile()); - rc = vfs()->xOpen(vfs(), kFileName, file2.get(), - SQLITE_OPEN_EXCLUSIVE | SQLITE_OPEN_CREATE, - &out_flags); - EXPECT_NE(SQLITE_OK, rc); - - file->pMethods->xClose(file.get()); -} - -TEST_F(VFSTest, NonexclusiveOpen) { - // Opening a non-existent file should work. - scoped_ptr file(MakeFile()); - int out_flags; - int rc = vfs()->xOpen(vfs(), kFileName, file.get(), - SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE, - &out_flags); - EXPECT_EQ(SQLITE_OK, rc); - - // Opening it a second time should work. - scoped_ptr file2(MakeFile()); - rc = vfs()->xOpen(vfs(), kFileName, file2.get(), - SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE, - &out_flags); - EXPECT_EQ(SQLITE_OK, rc); - - file->pMethods->xClose(file.get()); - file->pMethods->xClose(file2.get()); -} - -TEST_F(VFSTest, NullFilenameOpen) { - // Opening a file with a null filename should return a valid file object. - scoped_ptr file(MakeFile()); - int out_flags; - int rc = vfs()->xOpen( - vfs(), nullptr, file.get(), - SQLITE_OPEN_DELETEONCLOSE | SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE, - &out_flags); - EXPECT_EQ(SQLITE_OK, rc); - - file->pMethods->xClose(file.get()); -} - -TEST_F(VFSTest, DeleteOnClose) { - { - scoped_ptr file(MakeFile()); - int out_flags; - int rc = vfs()->xOpen( - vfs(), kFileName, file.get(), - SQLITE_OPEN_DELETEONCLOSE | SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE, - &out_flags); - EXPECT_EQ(SQLITE_OK, rc); - file->pMethods->xClose(file.get()); - } - - // The file shouldn't exist now. - int result = 0; - vfs()->xAccess(vfs(), kFileName, SQLITE_ACCESS_EXISTS, &result); - EXPECT_FALSE(result); -} - -TEST_F(VFSTest, TestNonExistence) { - // We shouldn't have a file exist yet in a fresh directory. - int result = 0; - vfs()->xAccess(vfs(), kFileName, SQLITE_ACCESS_EXISTS, &result); - EXPECT_FALSE(result); -} - -TEST_F(VFSTest, TestExistence) { - { - scoped_ptr file(MakeFile()); - int out_flags; - int rc = vfs()->xOpen(vfs(), kFileName, file.get(), - SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE, - &out_flags); - EXPECT_EQ(SQLITE_OK, rc); - - file->pMethods->xClose(file.get()); - } - - int result = 0; - vfs()->xAccess(vfs(), kFileName, SQLITE_ACCESS_EXISTS, &result); - EXPECT_TRUE(result); -} - -TEST_F(VFSTest, TestDelete) { - { - scoped_ptr file(MakeFile()); - int out_flags; - int rc = vfs()->xOpen(vfs(), kFileName, file.get(), - SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE, - &out_flags); - EXPECT_EQ(SQLITE_OK, rc); - - file->pMethods->xClose(file.get()); - } - - int result = 0; - vfs()->xAccess(vfs(), kFileName, SQLITE_ACCESS_EXISTS, &result); - EXPECT_TRUE(result); - - vfs()->xDelete(vfs(), kFileName, 0); - - vfs()->xAccess(vfs(), kFileName, SQLITE_ACCESS_EXISTS, &result); - EXPECT_FALSE(result); -} - -TEST_F(VFSTest, TestWriteAndRead) { - const char kBuffer[] = "One Two Three Four Five Six Seven"; - const int kBufferSize = arraysize(kBuffer); - - { - scoped_ptr file(MakeFile()); - int out_flags; - int rc = vfs()->xOpen(vfs(), kFileName, file.get(), - SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE, - &out_flags); - EXPECT_EQ(SQLITE_OK, rc); - - for (int i = 0; i < 10; ++i) { - rc = file->pMethods->xWrite(file.get(), kBuffer, kBufferSize, - i * kBufferSize); - EXPECT_EQ(SQLITE_OK, rc); - } - - file->pMethods->xClose(file.get()); - } - - // Expect that the size of the file is 10 * arraysize(kBuffer); - { - scoped_ptr file(MakeFile()); - int out_flags; - int rc = vfs()->xOpen(vfs(), kFileName, file.get(), - SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE, - &out_flags); - EXPECT_EQ(SQLITE_OK, rc); - - sqlite_int64 size; - rc = file->pMethods->xFileSize(file.get(), &size); - EXPECT_EQ(SQLITE_OK, rc); - EXPECT_EQ(10 * kBufferSize, size); - - file->pMethods->xClose(file.get()); - } - - // We should be able to read things back. - { - scoped_ptr file(MakeFile()); - int out_flags; - int rc = vfs()->xOpen(vfs(), kFileName, file.get(), - SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE, - &out_flags); - EXPECT_EQ(SQLITE_OK, rc); - - char data_buffer[kBufferSize]; - memset(data_buffer, '8', kBufferSize); - for (int i = 0; i < 10; ++i) { - rc = file->pMethods->xRead(file.get(), data_buffer, kBufferSize, - i * kBufferSize); - EXPECT_EQ(SQLITE_OK, rc); - EXPECT_TRUE(strncmp(kBuffer, &data_buffer[0], kBufferSize) == 0); - } - - file->pMethods->xClose(file.get()); - } -} - -TEST_F(VFSTest, PartialRead) { - const char kBuffer[] = "One Two Three Four Five Six Seven"; - const int kBufferSize = arraysize(kBuffer); - - // Write the data once. - { - scoped_ptr file(MakeFile()); - int out_flags; - int rc = vfs()->xOpen(vfs(), kFileName, file.get(), - SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE, - &out_flags); - EXPECT_EQ(SQLITE_OK, rc); - - rc = file->pMethods->xWrite(file.get(), kBuffer, kBufferSize, 0); - EXPECT_EQ(SQLITE_OK, rc); - - file->pMethods->xClose(file.get()); - } - - // Now attempt to read kBufferSize + 5 from a file sized to kBufferSize. - { - scoped_ptr file(MakeFile()); - int out_flags; - int rc = vfs()->xOpen(vfs(), kFileName, file.get(), - SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE, - &out_flags); - EXPECT_EQ(SQLITE_OK, rc); - - const char kBufferWithFiveNulls[] = - "One Two Three Four Five Six Seven\0\0\0\0\0"; - const int kBufferWithFiveNullsSize = arraysize(kBufferWithFiveNulls); - - char data_buffer[kBufferWithFiveNullsSize]; - memset(data_buffer, '8', kBufferWithFiveNullsSize); - rc = file->pMethods->xRead(file.get(), data_buffer, - kBufferWithFiveNullsSize, 0); - EXPECT_EQ(SQLITE_IOERR_SHORT_READ, rc); - - EXPECT_TRUE(strncmp(kBufferWithFiveNulls, &data_buffer[0], - kBufferWithFiveNullsSize) == 0); - - file->pMethods->xClose(file.get()); - } -} - -TEST_F(VFSTest, Truncate) { - const char kBuffer[] = "One Two Three Four Five Six Seven"; - const int kBufferSize = arraysize(kBuffer); - const int kCharsToThree = 13; - - scoped_ptr file(MakeFile()); - int out_flags; - int rc = vfs()->xOpen(vfs(), kFileName, file.get(), - SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE, - &out_flags); - EXPECT_EQ(SQLITE_OK, rc); - - rc = file->pMethods->xWrite(file.get(), kBuffer, kBufferSize, 0); - EXPECT_EQ(SQLITE_OK, rc); - - sqlite_int64 size; - rc = file->pMethods->xFileSize(file.get(), &size); - EXPECT_EQ(SQLITE_OK, rc); - EXPECT_EQ(kBufferSize, size); - - rc = file->pMethods->xTruncate(file.get(), kCharsToThree); - EXPECT_EQ(SQLITE_OK, rc); - - rc = file->pMethods->xFileSize(file.get(), &size); - EXPECT_EQ(SQLITE_OK, rc); - EXPECT_EQ(kCharsToThree, size); - - file->pMethods->xClose(file.get()); -} - -} // namespace sql -- cgit v1.1