delete webkit/support/simple_xxx's

webkit/support/simple_database_system.cc

Index: webkit/support/simple_database_system.cc
diff --git a/webkit/support/simple_database_system.cc b/webkit/support/simple_database_system.cc
deleted file mode 100644
index e9608721ebaf0e4ce47492febd6ee3229ba46931..0000000000000000000000000000000000000000
--- a/webkit/support/simple_database_system.cc
+++ /dev/null
@@ -1,319 +0,0 @@
-// 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 "webkit/support/simple_database_system.h"
-
-#include "base/auto_reset.h"
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/file_util.h"
-#include "base/message_loop.h"
-#include "base/message_loop/message_loop_proxy.h"
-#include "base/strings/utf_string_conversions.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/threading/platform_thread.h"
-#include "third_party/WebKit/public/platform/WebCString.h"
-#include "third_party/WebKit/public/platform/WebString.h"
-#include "third_party/WebKit/public/web/WebDatabase.h"
-#include "third_party/sqlite/sqlite3.h"
-#include "webkit/browser/database/database_util.h"
-#include "webkit/browser/database/vfs_backend.h"
-
-using webkit_database::DatabaseTracker;
-using webkit_database::DatabaseUtil;
-using webkit_database::OriginInfo;
-using webkit_database::VfsBackend;
-
-SimpleDatabaseSystem* SimpleDatabaseSystem::instance_ = NULL;
-
-SimpleDatabaseSystem* SimpleDatabaseSystem::GetInstance() {
-  DCHECK(instance_);
-  return instance_;
-}
-
-SimpleDatabaseSystem::SimpleDatabaseSystem()
-    : db_thread_("SimpleDBThread"),
-      quota_per_origin_(5 * 1024 * 1024),
-      open_connections_(new webkit_database::DatabaseConnectionsWrapper) {
-  DCHECK(!instance_);
-  instance_ = this;
-  CHECK(temp_dir_.CreateUniqueTempDir());
-  db_tracker_ =
-      new DatabaseTracker(temp_dir_.path(), false, NULL, NULL, NULL);
-  db_tracker_->AddObserver(this);
-  db_thread_.Start();
-  db_thread_proxy_ = db_thread_.message_loop_proxy();
-}
-
-SimpleDatabaseSystem::~SimpleDatabaseSystem() {
-  base::WaitableEvent done_event(false, false);
-  db_thread_proxy_->PostTask(
-      FROM_HERE,
-      base::Bind(&SimpleDatabaseSystem::ThreadCleanup,
-                 base::Unretained(this), &done_event));
-  done_event.Wait();
-  instance_ = NULL;
-}
-
-void SimpleDatabaseSystem::databaseOpened(const WebKit::WebDatabase& database) {
-  std::string origin_identifier =
-      database.securityOrigin().databaseIdentifier().utf8();
-  base::string16 database_name = database.name();
-  open_connections_->AddOpenConnection(origin_identifier, database_name);
-  db_thread_proxy_->PostTask(
-      FROM_HERE,
-      base::Bind(&SimpleDatabaseSystem::DatabaseOpened,
-                 base::Unretained(this),
-                 origin_identifier,
-                 database_name, database.displayName(),
-                 database.estimatedSize()));
-}
-
-void SimpleDatabaseSystem::databaseModified(
-    const WebKit::WebDatabase& database) {
-  db_thread_proxy_->PostTask(
-      FROM_HERE,
-      base::Bind(&SimpleDatabaseSystem::DatabaseModified,
-                 base::Unretained(this),
-                 database.securityOrigin().databaseIdentifier().utf8(),
-                 database.name()));
-}
-
-void SimpleDatabaseSystem::databaseClosed(const WebKit::WebDatabase& database) {
-  std::string origin_identifier =
-      database.securityOrigin().databaseIdentifier().utf8();
-  base::string16 database_name = database.name();
-  db_thread_proxy_->PostTask(
-      FROM_HERE,
-      base::Bind(&SimpleDatabaseSystem::DatabaseClosed,
-                 base::Unretained(this), origin_identifier, database_name));
-}
-
-base::PlatformFile SimpleDatabaseSystem::OpenFile(
-    const base::string16& vfs_file_name, int desired_flags) {
-  base::PlatformFile result = base::kInvalidPlatformFileValue;
-  base::WaitableEvent done_event(false, false);
-  db_thread_proxy_->PostTask(
-      FROM_HERE,
-      base::Bind(&SimpleDatabaseSystem::VfsOpenFile,
-                 base::Unretained(this),
-                 vfs_file_name, desired_flags,
-                 &result, &done_event));
-  done_event.Wait();
-  return result;
-}
-
-int SimpleDatabaseSystem::DeleteFile(
-    const base::string16& vfs_file_name, bool sync_dir) {
-  int result = SQLITE_OK;
-  base::WaitableEvent done_event(false, false);
-  db_thread_proxy_->PostTask(
-      FROM_HERE,
-      base::Bind(&SimpleDatabaseSystem::VfsDeleteFile,
-                 base::Unretained(this),
-                 vfs_file_name, sync_dir,
-                 &result, &done_event));
-  done_event.Wait();
-  return result;
-}
-
-uint32 SimpleDatabaseSystem::GetFileAttributes(
-    const base::string16& vfs_file_name) {
-  uint32 result = 0;
-  base::WaitableEvent done_event(false, false);
-  db_thread_proxy_->PostTask(
-      FROM_HERE,
-      base::Bind(&SimpleDatabaseSystem::VfsGetFileAttributes,
-                 base::Unretained(this), vfs_file_name, &result, &done_event));
-  done_event.Wait();
-  return result;
-}
-
-int64 SimpleDatabaseSystem::GetFileSize(const base::string16& vfs_file_name) {
-  int64 result = 0;
-  base::WaitableEvent done_event(false, false);
-  db_thread_proxy_->PostTask(
-      FROM_HERE,
-      base::Bind(&SimpleDatabaseSystem::VfsGetFileSize,
-                 base::Unretained(this), vfs_file_name, &result, &done_event));
-  done_event.Wait();
-  return result;
-}
-
-int64 SimpleDatabaseSystem::GetSpaceAvailable(
-    const std::string& origin_identifier) {
-  int64 result = 0;
-  base::WaitableEvent done_event(false, false);
-  db_thread_proxy_->PostTask(
-      FROM_HERE,
-      base::Bind(&SimpleDatabaseSystem::VfsGetSpaceAvailable,
-                 base::Unretained(this), origin_identifier,
-                 &result, &done_event));
-  done_event.Wait();
-  return result;
-}
-
-void SimpleDatabaseSystem::ClearAllDatabases() {
-  open_connections_->WaitForAllDatabasesToClose();
-  db_thread_proxy_->PostTask(
-      FROM_HERE,
-      base::Bind(&SimpleDatabaseSystem::ResetTracker, base::Unretained(this)));
-}
-
-void SimpleDatabaseSystem::SetDatabaseQuota(int64 quota) {
-  if (!db_thread_proxy_->BelongsToCurrentThread()) {
-    db_thread_proxy_->PostTask(
-        FROM_HERE,
-        base::Bind(&SimpleDatabaseSystem::SetDatabaseQuota,
-                   base::Unretained(this), quota));
-    return;
-  }
-  quota_per_origin_ = quota;
-}
-
-void SimpleDatabaseSystem::DatabaseOpened(
-    const std::string& origin_identifier,
-    const base::string16& database_name,
-    const base::string16& description,
-    int64 estimated_size) {
-  DCHECK(db_thread_proxy_->BelongsToCurrentThread());
-  int64 database_size = 0;
-  db_tracker_->DatabaseOpened(
-      origin_identifier, database_name, description,
-      estimated_size, &database_size);
-  OnDatabaseSizeChanged(origin_identifier, database_name,
-                        database_size);
-}
-
-void SimpleDatabaseSystem::DatabaseModified(
-    const std::string& origin_identifier,
-    const base::string16& database_name) {
-  DCHECK(db_thread_proxy_->BelongsToCurrentThread());
-  db_tracker_->DatabaseModified(origin_identifier, database_name);
-}
-
-void SimpleDatabaseSystem::DatabaseClosed(
-    const std::string& origin_identifier,
-    const base::string16& database_name) {
-  DCHECK(db_thread_proxy_->BelongsToCurrentThread());
-  db_tracker_->DatabaseClosed(origin_identifier, database_name);
-  open_connections_->RemoveOpenConnection(origin_identifier, database_name);
-}
-
-void SimpleDatabaseSystem::OnDatabaseSizeChanged(
-    const std::string& origin_identifier,
-    const base::string16& database_name,
-    int64 database_size) {
-  DCHECK(db_thread_proxy_->BelongsToCurrentThread());
-  // We intentionally call into webkit on our background db_thread_
-  // to better emulate what happens in chrome where this method is
-  // invoked on the background ipc thread.
-  WebKit::WebDatabase::updateDatabaseSize(
-      WebKit::WebString::fromUTF8(origin_identifier),
-      database_name, database_size);
-}
-
-void SimpleDatabaseSystem::OnDatabaseScheduledForDeletion(
-    const std::string& origin_identifier,
-    const base::string16& database_name) {
-  DCHECK(db_thread_proxy_->BelongsToCurrentThread());
-  // We intentionally call into webkit on our background db_thread_
-  // to better emulate what happens in chrome where this method is
-  // invoked on the background ipc thread.
-  WebKit::WebDatabase::closeDatabaseImmediately(
-      WebKit::WebString::fromUTF8(origin_identifier), database_name);
-}
-
-void SimpleDatabaseSystem::VfsOpenFile(
-    const base::string16& vfs_file_name, int desired_flags,
-    base::PlatformFile* file_handle, base::WaitableEvent* done_event ) {
-  DCHECK(db_thread_proxy_->BelongsToCurrentThread());
-  base::FilePath file_name = GetFullFilePathForVfsFile(vfs_file_name);
-  if (file_name.empty()) {
-    VfsBackend::OpenTempFileInDirectory(
-        db_tracker_->DatabaseDirectory(), desired_flags, file_handle);
-  } else {
-    VfsBackend::OpenFile(file_name, desired_flags, file_handle);
-  }
-  done_event->Signal();
-}
-
-void SimpleDatabaseSystem::VfsDeleteFile(
-    const base::string16& vfs_file_name, bool sync_dir,
-    int* result, base::WaitableEvent* done_event) {
-  DCHECK(db_thread_proxy_->BelongsToCurrentThread());
-  // We try to delete the file multiple times, because that's what the default
-  // VFS does (apparently deleting a file can sometimes fail on Windows).
-  // We sleep for 10ms between retries for the same reason.
-  const int kNumDeleteRetries = 3;
-  int num_retries = 0;
-  *result = SQLITE_OK;
-  base::FilePath file_name = GetFullFilePathForVfsFile(vfs_file_name);
-  do {
-    *result = VfsBackend::DeleteFile(file_name, sync_dir);
-  } while ((++num_retries < kNumDeleteRetries) &&
-           (*result == SQLITE_IOERR_DELETE) &&
-           (base::PlatformThread::Sleep(
-               base::TimeDelta::FromMilliseconds(10)),
-            1));
-
-  done_event->Signal();
-}
-
-void SimpleDatabaseSystem::VfsGetFileAttributes(
-    const base::string16& vfs_file_name,
-    uint32* result, base::WaitableEvent* done_event) {
-  DCHECK(db_thread_proxy_->BelongsToCurrentThread());
-  *result = VfsBackend::GetFileAttributes(
-      GetFullFilePathForVfsFile(vfs_file_name));
-  done_event->Signal();
-}
-
-void SimpleDatabaseSystem::VfsGetFileSize(
-    const base::string16& vfs_file_name,
-    int64* result, base::WaitableEvent* done_event) {
-  DCHECK(db_thread_proxy_->BelongsToCurrentThread());
-  *result = VfsBackend::GetFileSize(GetFullFilePathForVfsFile(vfs_file_name));
-  done_event->Signal();
-}
-
-void SimpleDatabaseSystem::VfsGetSpaceAvailable(
-    const std::string& origin_identifier,
-    int64* result, base::WaitableEvent* done_event) {
-  DCHECK(db_thread_proxy_->BelongsToCurrentThread());
-  // This method isn't actually part of the "vfs" interface, but it is
-  // used from within webcore and handled here in the same fashion.
-  OriginInfo info;
-  if (db_tracker_->GetOriginInfo(origin_identifier, &info)) {
-    int64 space_available = quota_per_origin_ - info.TotalSize();
-    *result = space_available < 0 ? 0 : space_available;
-  } else {
-    NOTREACHED();
-    *result = 0;
-  }
-  done_event->Signal();
-}
-
-base::FilePath SimpleDatabaseSystem::GetFullFilePathForVfsFile(
-    const base::string16& vfs_file_name) {
-  DCHECK(db_thread_proxy_->BelongsToCurrentThread());
-  if (vfs_file_name.empty())  // temp file, used for vacuuming
-    return base::FilePath();
-  return DatabaseUtil::GetFullFilePathForVfsFile(
-      db_tracker_.get(), vfs_file_name);
-}
-
-void SimpleDatabaseSystem::ResetTracker() {
-  DCHECK(db_thread_proxy_->BelongsToCurrentThread());
-  db_tracker_->CloseTrackerDatabaseAndClearCaches();
-  file_util::Delete(db_tracker_->DatabaseDirectory(), true);
-}
-
-void SimpleDatabaseSystem::ThreadCleanup(base::WaitableEvent* done_event) {
-  ResetTracker();
-  db_tracker_->RemoveObserver(this);
-  db_tracker_ = NULL;
-  done_event->Signal();
-}
-