AppCache + Quota integration

webkit/appcache/appcache_database.cc

 // Copyright (c) 2010 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/appcache/appcache_database.h"
 
 #include "app/sql/connection.h"
 #include "app/sql/diagnostic_error_delegate.h"
 #include "app/sql/meta_table.h"
 #include "app/sql/statement.h"
 #include "app/sql/transaction.h"
 #include "base/auto_reset.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/utf_string_conversions.h"
 #include "webkit/appcache/appcache_entry.h"
 #include "webkit/appcache/appcache_histograms.h"
-#include "webkit/database/quota_table.h"
 
 // Schema -------------------------------------------------------------------
 namespace {
 
 const int kCurrentVersion = 3;
 const int kCompatibleVersion = 3;
 
 const char* kGroupsTable = "Groups";
 const char* kCachesTable = "Caches";
 const char* kEntriesTable = "Entries";
@@ skipping 160 matching lines @@
 
   int64 origin_usage = 0;
   std::vector<CacheRecord>::const_iterator iter = records.begin();
   while (iter != records.end()) {
     origin_usage += iter->cache_size;
     ++iter;
   }
   return origin_usage;
 }
 
-int64 AppCacheDatabase::GetOriginQuota(const GURL& origin) {
-  if (!LazyOpen(false))
-    return GetDefaultOriginQuota();
-  int64 quota = quota_table_->GetOriginQuota(
-      UTF8ToUTF16(origin.spec().c_str()));
-  return (quota >= 0) ? quota : GetDefaultOriginQuota();
+bool AppCacheDatabase::GetAllOriginUsage(std::map<GURL, int64>* usage_map) {
+  std::set<GURL> origins;
+  if (!FindOriginsWithGroups(&origins))
+    return false;
+  for (std::set<GURL>::const_iterator origin = origins.begin();
+       origin != origins.end(); ++origin) {
+    (*usage_map)[*origin] = GetOriginUsage(*origin);
+  }
+  return true;
 }
 
 bool AppCacheDatabase::FindOriginsWithGroups(std::set<GURL>* origins) {
   DCHECK(origins && origins->empty());
   if (!LazyOpen(false))
     return false;
 
   const char* kSql =
       "SELECT DISTINCT(origin) FROM Groups";
 
@@ skipping 782 matching lines @@
 
   // Avoid creating a database at all if we can.
   bool use_in_memory_db = db_file_path_.empty();
   if (!create_if_needed &&
       (use_in_memory_db || !file_util::PathExists(db_file_path_))) {
     return false;
   }
 
   db_.reset(new sql::Connection);
   meta_table_.reset(new sql::MetaTable);
-  quota_table_.reset(new webkit_database::QuotaTable(db_.get()));
 
   db_->set_error_delegate(GetErrorHandlerForAppCacheDb());
 
   bool opened = false;
   if (use_in_memory_db) {
     opened = db_->OpenInMemory();
   } else if (!file_util::CreateDirectory(db_file_path_.DirName())) {
     LOG(ERROR) << "Failed to create appcache directory.";
   } else {
     opened = db_->Open(db_file_path_);
@@ skipping 44 matching lines @@
 #endif
 
   return true;
 }
 
 bool AppCacheDatabase::CreateSchema() {
   sql::Transaction transaction(db_.get());
   if (!transaction.Begin())
     return false;
 
-  if (!meta_table_->Init(db_.get(), kCurrentVersion, kCompatibleVersion) ||
-      !quota_table_->Init()) {
+  if (!meta_table_->Init(db_.get(), kCurrentVersion, kCompatibleVersion))
     return false;
-  }
 
   for (int i = 0; i < kTableCount; ++i) {
     std::string sql("CREATE TABLE ");
     sql += kTables[i].table_name;
     sql += kTables[i].columns;
     if (!db_->Execute(sql.c_str()))
       return false;
   }
 
   for (int i = 0; i < kIndexCount; ++i) {
@@ skipping 15 matching lines @@
 
 bool AppCacheDatabase::UpgradeSchema() {
   // Upgrade logic goes here
 
   // If there is no upgrade path for the version on disk to the current
   // version, nuke everything and start over.
   return DeleteExistingAndCreateNewDatabase();
 }
 
 void AppCacheDatabase::ResetConnectionAndTables() {
-  quota_table_.reset();
   meta_table_.reset();
   db_.reset();
 }
 
 bool AppCacheDatabase::DeleteExistingAndCreateNewDatabase() {
   DCHECK(!db_file_path_.empty());
   DCHECK(file_util::PathExists(db_file_path_));
   VLOG(1) << "Deleting existing appcache data and starting over.";
 
   ResetConnectionAndTables();
@@ skipping 11 matching lines @@
 
   // So we can't go recursive.
   if (is_recreating_)
     return false;
 
   AutoReset<bool> auto_reset(&is_recreating_, true);
   return LazyOpen(true);
 }
 
 }  // namespace appcache