Reset the default quota limit for extensions to 5MB, but add a...

webkit/database/database_tracker.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/database/database_tracker.h"
 
 #include <vector>
 
 #include "app/sql/connection.h"
 #include "app/sql/meta_table.h"
 #include "app/sql/statement.h"
 #include "app/sql/transaction.h"
 #include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/string_util.h"
 #include "net/base/net_errors.h"
 #include "webkit/database/databases_table.h"
 #include "webkit/database/quota_table.h"
-#include "webkit/glue/webkit_glue.h"
 
 namespace webkit_database {
 
 const FilePath::CharType kDatabaseDirectoryName[] =
     FILE_PATH_LITERAL("databases");
 const FilePath::CharType kTrackerDatabaseFileName[] =
     FILE_PATH_LITERAL("Databases.db");
 const int kCurrentVersion = 2;
 const int kCompatibleVersion = 1;
-const int64 kDefaultExtensionQuota = 1024 * 1024 * 1024;
 const char* kExtensionOriginIdentifierPrefix = "chrome-extension_";
 
 DatabaseTracker::DatabaseTracker(const FilePath& profile_path)
     : initialized_(false),
       db_dir_(profile_path.Append(FilePath(kDatabaseDirectoryName))),
       db_(new sql::Connection()),
       databases_table_(NULL),
       meta_table_(NULL),
       default_quota_(5 * 1024 * 1024) {
 }
@@ skipping 110 matching lines @@
   quota_table_.reset(NULL);
   db_->Close();
   initialized_ = false;
 }
 
 FilePath DatabaseTracker::GetFullDBFilePath(
     const string16& origin_identifier,
     const string16& database_name) const {
   DCHECK(!origin_identifier.empty());
   DCHECK(!database_name.empty());
+
   int64 id = databases_table_->GetDatabaseID(
       origin_identifier, database_name);
   if (id < 0)
     return FilePath();
 
   FilePath file_name = FilePath::FromWStringHack(Int64ToWString(id));
   return db_dir_.Append(FilePath::FromWStringHack(
       UTF16ToWide(origin_identifier))).Append(file_name);
 }
 
@@ skipping 16 matching lines @@
       return false;
     }
     origins_info->push_back(OriginInfo(*origin_info));
   }
 
   return true;
 }
 
 void DatabaseTracker::SetOriginQuota(const string16& origin_identifier,
                                      int64 new_quota) {
+  if (!LazyInit())
+    return;
+
   if (quota_table_->SetOriginQuota(origin_identifier, new_quota) &&
       (origins_info_map_.find(origin_identifier) != origins_info_map_.end())) {
     origins_info_map_[origin_identifier].SetQuota(new_quota);
   }
 }
 
+void DatabaseTracker::SetOriginQuotaInMemory(const string16& origin_identifier,
+                                             int64 new_quota) {
+  DCHECK(new_quota >= 0);
+  in_memory_quotas_[origin_identifier] = new_quota;
+}
+
 bool DatabaseTracker::DeleteClosedDatabase(const string16& origin_identifier,
                                            const string16& database_name) {
+  if (!LazyInit())
+    return false;
+
   // Check if the database is opened by any renderer.
   if (database_connections_.IsDatabaseOpened(origin_identifier, database_name))
     return false;
 
   // Try to delete the file on the hard drive.
   // TODO(jochen): Delete journal files associated with this database.
   FilePath db_file = GetFullDBFilePath(origin_identifier, database_name);
   if (file_util::PathExists(db_file) && !file_util::Delete(db_file, false))
     return false;
 
   // Clean up the main database and invalidate the cached record.
   databases_table_->DeleteDatabaseDetails(origin_identifier, database_name);
   origins_info_map_.erase(origin_identifier);
 
   // Try to delete the origin in case this was the last database.
   std::vector<DatabaseDetails> details;
   if (databases_table_->GetAllDatabaseDetailsForOrigin(
           origin_identifier, &details) && details.empty())
     DeleteOrigin(origin_identifier);
   return true;
 }
 
 bool DatabaseTracker::DeleteOrigin(const string16& origin_identifier) {
+  if (!LazyInit())
+    return false;
+
   // Check if any database in this origin is opened by any renderer.
   if (database_connections_.IsOriginUsed(origin_identifier))
     return false;
 
   // We need to invalidate the cached record whether file_util::Delete()
   // succeeds or not, because even if it fails, it might still delete some
   // DB files on the hard drive.
   origins_info_map_.erase(origin_identifier);
   FilePath origin_dir = db_dir_.Append(FilePath::FromWStringHack(
       UTF16ToWide(origin_identifier)));
@@ skipping 109 matching lines @@
     CachedOriginInfo& origin_info = origins_info_map_[origin_identifier];
     origin_info.SetOrigin(origin_identifier);
     for (std::vector<DatabaseDetails>::const_iterator it = details.begin();
          it != details.end(); it++) {
       int64 db_file_size =
           GetDBFileSize(origin_identifier, it->database_name);
       origin_info.SetDatabaseSize(it->database_name, db_file_size);
       origin_info.SetDatabaseDescription(it->database_name, it->description);
     }
 
-    int64 origin_quota = quota_table_->GetOriginQuota(origin_identifier);
-    if (origin_quota > 0) {
-      origin_info.SetQuota(origin_quota);
-    } else if (StartsWith(origin_identifier,
-                          ASCIIToUTF16(kExtensionOriginIdentifierPrefix),
-                          true)) {
-      origin_info.SetQuota(kDefaultExtensionQuota);
+    if (in_memory_quotas_.find(origin_identifier) != in_memory_quotas_.end()) {
+      origin_info.SetQuota(in_memory_quotas_[origin_identifier]);
     } else {
-      origin_info.SetQuota(default_quota_);
+      int64 origin_quota = quota_table_->GetOriginQuota(origin_identifier);
+      if (origin_quota > 0)
+        origin_info.SetQuota(origin_quota);
+      else
+        origin_info.SetQuota(default_quota_);
     }
   }
 
   return &origins_info_map_[origin_identifier];
 }
 
 int64 DatabaseTracker::GetDBFileSize(const string16& origin_identifier,
                                      const string16& database_name) const {
   FilePath db_file_name = GetFullDBFilePath(origin_identifier, database_name);
   int64 db_file_size = 0;
@@ skipping 133 matching lines @@
        file_path = file_enumerator.Next()) {
     if (file_path.BaseName() != FilePath(kTrackerDatabaseFileName)) {
       if (!StartsWith(file_path.BaseName().ToWStringHack(),
                       ASCIIToWide(kExtensionOriginIdentifierPrefix), true))
         file_util::Delete(file_path, true);
     }
   }
 }
 
 }  // namespace webkit_database