DB quota

webkit/support/simple_database_system.cc

 // Copyright (c) 2011 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/file_util.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "base/utf_string_conversions.h"
 #include "third_party/sqlite/sqlite3.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDatabase.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebString.h"
 #include "webkit/database/database_util.h"
 #include "webkit/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();
 }
 
@@ skipping 70 matching lines @@
 int64 SimpleDatabaseSystem::GetFileSize(const string16& vfs_file_name) {
   int64 result = 0;
   base::WaitableEvent done_event(false, false);
   db_thread_proxy_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &SimpleDatabaseSystem::VfsGetFileSize,
                         vfs_file_name, &result, &done_event));
   done_event.Wait();
   return result;
 }
 
+int64 SimpleDatabaseSystem::GetSpaceAvailable(
+    const string16& origin_identifier) {
+  int64 result = 0;
+  base::WaitableEvent done_event(false, false);
+  db_thread_proxy_->PostTask(FROM_HERE,
+      NewRunnableMethod(this, &SimpleDatabaseSystem::VfsGetSpaceAvailable,
+                        origin_identifier, &result, &done_event));
+  done_event.Wait();
+  return result;
+}
+
 void SimpleDatabaseSystem::ClearAllDatabases() {
   open_connections_->WaitForAllDatabasesToClose();
   db_thread_proxy_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &SimpleDatabaseSystem::ResetTracker));
 }
 
 void SimpleDatabaseSystem::SetDatabaseQuota(int64 quota) {
   if (!db_thread_proxy_->BelongsToCurrentThread()) {
     db_thread_proxy_->PostTask(FROM_HERE,
         NewRunnableMethod(this, &SimpleDatabaseSystem::SetDatabaseQuota,
                           quota));
     return;
   }
-  db_tracker_->SetDefaultQuota(quota);
+  quota_per_origin_ = quota;
 }
 
 void SimpleDatabaseSystem::DatabaseOpened(const string16& origin_identifier,
                                           const string16& database_name,
                                           const string16& description,
                                           int64 estimated_size) {
   DCHECK(db_thread_proxy_->BelongsToCurrentThread());
   int64 database_size = 0;
-  int64 space_available = 0;
+  int64 space_available_not_used = 0;
   db_tracker_->DatabaseOpened(
       origin_identifier, database_name, description,
-      estimated_size, &database_size, &space_available);
+      estimated_size, &database_size, &space_available_not_used);
   OnDatabaseSizeChanged(origin_identifier, database_name,
-                        database_size, space_available);
+                        database_size, 0);
 }
 
 void SimpleDatabaseSystem::DatabaseModified(const string16& origin_identifier,
                                             const string16& database_name) {
   DCHECK(db_thread_proxy_->BelongsToCurrentThread());
   db_tracker_->DatabaseModified(origin_identifier, database_name);
 }
 
 void SimpleDatabaseSystem::DatabaseClosed(const string16& origin_identifier,
                                           const 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 string16& origin_identifier,
     const string16& database_name,
     int64 database_size,
-    int64 space_available) {
+    int64 space_available_not_used) {
   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(
-      origin_identifier, database_name, database_size, space_available);
+      origin_identifier, database_name, database_size);
 }
 
 void SimpleDatabaseSystem::OnDatabaseScheduledForDeletion(
     const string16& origin_identifier,
     const 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(
@@ skipping 44 matching lines @@
 }
 
 void SimpleDatabaseSystem::VfsGetFileSize(
     const 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 string16& 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();

[darin (slow to review), 2011/05/24 04:56:11]

are you sure it is safe to delete done_event before Signal returns?  i'm pretty
sure this'll be ok on windows, but i'm not so sure about the posix
implementation of waitable_event_posix.cc.  i recall talking to agl about how we
should consider changing it to support this use case.

[michaeln, 2011/05/24 05:10:54]

right... i remember that too... i'll check, the other uses like this haven't
cropped up as problems so maybe he posix impl was fixed (wishful thinking).

+}
+
 FilePath SimpleDatabaseSystem::GetFullFilePathForVfsFile(
     const string16& vfs_file_name) {
   DCHECK(db_thread_proxy_->BelongsToCurrentThread());
   if (vfs_file_name.empty())  // temp file, used for vacuuming
     return 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();
 }