Revert r84963: "Added {Get,Set}PersistentHostQuota"

failures in webkit tests:
QuotaManagerTest.GetUsage_WithModification:
.\quota\quota_manager_unittest.cc(645): error: Value of: 4000 + 50000 + 900000000
  Actual: 900054000
Expected: usage()
Which is: 900108000

BUG=None
TEST=None
TBR=tzik@google.com

Review URL: http://codereview.chromium.org/7004018

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@84968 0039d316-1c4b-4281-b951-d872f2087c98

6 files changed, 81 insertions, 718 deletions

diff --git a/webkit/quota/mock_storage_client.cc b/webkit/quota/mock_storage_client.cc
index 74f5e28..ee1a0b1 100644
--- a/webkit/quota/mock_storage_client.cc
+++ b/webkit/quota/mock_storage_client.cc
@@ -19,8 +19,6 @@ namespace quota {
 
 namespace {
 
-using std::make_pair;
-
 class MockStorageClientIDSequencer {
  public:
   static MockStorageClientIDSequencer* GetInstance() {
@@ -56,21 +54,17 @@ MockStorageClient::~MockStorageClient() {
 
 void MockStorageClient::AddMockOriginData(
     const GURL& origin_url, StorageType type, int64 size) {
-  origin_data_[make_pair(origin_url, type)] = size;
+  origin_data_.insert(std::make_pair(origin_url, MockOriginData(type, size)));
 }
 
 void MockStorageClient::ModifyMockOriginDataSize(
     const GURL& origin_url, StorageType type, int64 delta) {
-  OriginDataMap::iterator find = origin_data_.find(make_pair(origin_url, type));
-  if (find == origin_data_.end()) {
+  std::map<GURL, MockOriginData>::iterator find = origin_data_.find(origin_url);
+  if (find == origin_data_.end() || find->second.type != type) {
     DCHECK(delta >= 0);
     AddMockOriginData(origin_url, type, delta);
     return;
   }
-  find->second += delta;
-  DCHECK(find->second >= 0);
-
-  // TODO(tzik): Check quota to prevent usage exceed
   quota_manager_proxy_->NotifyStorageModified(id(), origin_url, type, delta);
 }
 
@@ -115,11 +109,11 @@ void MockStorageClient::RunGetOriginUsage(
     const GURL& origin_url, StorageType type, GetUsageCallback* callback_ptr) {
   usage_callbacks_.erase(callback_ptr);
   scoped_ptr<GetUsageCallback> callback(callback_ptr);
-  OriginDataMap::iterator find = origin_data_.find(make_pair(origin_url, type));
+  std::map<GURL, MockOriginData>::iterator find = origin_data_.find(origin_url);
   if (find == origin_data_.end()) {
     callback->Run(0);
   } else {
-    callback->Run(find->second);
+    callback->Run(find->second.usage);
   }
 }
 
@@ -128,10 +122,10 @@ void MockStorageClient::RunGetOriginsForType(
   scoped_ptr<GetOriginsCallback> callback(callback_ptr);
   origins_callbacks_.erase(callback_ptr);
   std::set<GURL> origins;
-  for (OriginDataMap::iterator iter = origin_data_.begin();
+  for (std::map<GURL, MockOriginData>::iterator iter = origin_data_.begin();
        iter != origin_data_.end(); ++iter) {
-    if (type == iter->first.second)
-      origins.insert(iter->first.first);
+    if (type == iter->second.type)
+      origins.insert(iter->first);
   }
   callback->Run(origins);
 }
@@ -142,11 +136,11 @@ void MockStorageClient::RunGetOriginsForHost(
   scoped_ptr<GetOriginsCallback> callback(callback_ptr);
   origins_callbacks_.erase(callback_ptr);
   std::set<GURL> origins;
-  for (OriginDataMap::iterator iter = origin_data_.begin();
+  for (std::map<GURL, MockOriginData>::iterator iter = origin_data_.begin();
        iter != origin_data_.end(); ++iter) {
-    std::string host_or_spec = net::GetHostOrSpecFromURL(iter->first.first);
-    if (type == iter->first.second && host == host_or_spec)
-      origins.insert(iter->first.first);
+    std::string host_or_spec = net::GetHostOrSpecFromURL(iter->first);
+    if (type == iter->second.type && host == host_or_spec)
+      origins.insert(iter->first);
   }
   callback->Run(origins);
 }
diff --git a/webkit/quota/mock_storage_client.h b/webkit/quota/mock_storage_client.h
index e1ad61e..ac2545b 100644
--- a/webkit/quota/mock_storage_client.h
+++ b/webkit/quota/mock_storage_client.h
@@ -51,8 +51,12 @@ class MockStorageClient : public QuotaClient {
   scoped_refptr<QuotaManagerProxy> quota_manager_proxy_;
   const ID id_;
 
-  typedef std::map<std::pair<GURL, StorageType>, int64> OriginDataMap;
-  OriginDataMap origin_data_;
+  struct MockOriginData {
+    MockOriginData(StorageType type, int64 usage) : type(type), usage(usage) { }
+    StorageType type;
+    int64 usage;
+  };
+  std::map<GURL, MockOriginData> origin_data_;
 
   std::set<GetUsageCallback*> usage_callbacks_;
   std::set<GetOriginsCallback*> origins_callbacks_;
diff --git a/webkit/quota/quota_manager.cc b/webkit/quota/quota_manager.cc
index 2e2db35..16b44ef 100644
--- a/webkit/quota/quota_manager.cc
+++ b/webkit/quota/quota_manager.cc
@@ -84,16 +84,12 @@ class QuotaManager::UsageAndQuotaDispatcherTask : public QuotaTask {
     CheckCompleted();
   }
 
-  void DidGetGlobalQuota(QuotaStatusCode status, int64 quota) {
-    quota_status_ = status;
+  void DidGetGlobalQuota(int64 quota) {
     quota_ = quota;
     CheckCompleted();
   }
 
-  void DidGetHostQuota(QuotaStatusCode status,
-                       const std::string& host_unused,
-                       int64 quota) {
-    quota_status_ = status;
+  void DidGetHostQuota(const std::string& host_unused, int64 quota) {
     quota_ = quota;
     CheckCompleted();
   }
@@ -109,7 +105,6 @@ class QuotaManager::UsageAndQuotaDispatcherTask : public QuotaTask {
         quota_(-1),
         global_usage_(-1),
         host_usage_(-1),
-        quota_status_(kQuotaStatusUnknown),
         callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {}
 
   virtual ~UsageAndQuotaDispatcherTask() {
@@ -141,7 +136,6 @@ class QuotaManager::UsageAndQuotaDispatcherTask : public QuotaTask {
   int64 quota() const { return quota_; }
   int64 global_usage() const { return global_usage_; }
   int64 host_usage() const { return host_usage_; }
-  QuotaStatusCode status() const { return quota_status_; }
 
   UsageCallback* NewGlobalUsageCallback() {
     return callback_factory_.NewCallback(
@@ -188,7 +182,6 @@ class QuotaManager::UsageAndQuotaDispatcherTask : public QuotaTask {
   int64 quota_;
   int64 global_usage_;
   int64 host_usage_;
-  QuotaStatusCode quota_status_;
   CallbackList callbacks_;
   ScopedCallbackFactory<UsageAndQuotaDispatcherTask> callback_factory_;
 
@@ -220,7 +213,7 @@ class QuotaManager::UsageAndQuotaDispatcherTaskForTemporary
     // to return {usage, quota - nonevictable_usage} once eviction is
     // supported.
     int64 other_usage = global_usage() - host_usage();
-    callback->Run(status(), host_usage(), quota() - other_usage);
+    callback->Run(kQuotaStatusOk, host_usage(), quota() - other_usage);
   }
 };
 
@@ -244,7 +237,7 @@ class QuotaManager::UsageAndQuotaDispatcherTaskForPersistent
   }
 
   virtual void DispatchCallback(GetUsageAndQuotaCallback* callback) OVERRIDE {
-    callback->Run(status(), host_usage(), quota());
+    callback->Run(kQuotaStatusOk, host_usage(), quota());
   }
 };
 
@@ -299,10 +292,10 @@ class QuotaManager::InitializeTask : public QuotaThreadTask {
 
   virtual void Completed() OVERRIDE {
     DCHECK(manager_);
-    manager_->db_initialized_ = !db_disabled_;
-    manager_->db_disabled_ = db_disabled_;
     if (manager_->temporary_global_quota_ < 0)
       manager_->DidGetTemporaryGlobalQuota(temporary_storage_quota_);
+    manager_->db_initialized_ = !db_disabled_;
+    manager_->db_disabled_ = db_disabled_;
   }
 
  private:
@@ -313,122 +306,36 @@ class QuotaManager::InitializeTask : public QuotaThreadTask {
   bool db_disabled_;
 };
 
-class QuotaManager::TemporaryGlobalQuotaUpdateTask
-    : public QuotaThreadTask {
+class QuotaManager::TemporaryGlobalQuotaUpdateTask : public QuotaThreadTask {
  public:
   TemporaryGlobalQuotaUpdateTask(
       QuotaManager* manager,
       QuotaDatabase* database,
       scoped_refptr<base::MessageLoopProxy> db_message_loop,
-      int64 new_quota,
-      QuotaCallback* callback)
+      int64 new_quota)
       : QuotaThreadTask(manager, db_message_loop),
         manager_(manager),
         database_(database),
         new_quota_(new_quota),
-        callback_(callback),
         db_disabled_(false) {
     DCHECK(database_);
-    DCHECK(new_quota >=0);
   }
 
  protected:
   virtual void RunOnTargetThread() OVERRIDE {
-    if (!database_->SetGlobalQuota(kStorageTypeTemporary, new_quota_)) {
+    if (!database_->SetGlobalQuota(kStorageTypeTemporary, new_quota_))
       db_disabled_ = true;
-      new_quota_ = 0;
-    }
   }
 
   virtual void Completed() OVERRIDE {
     DCHECK(manager_);
     manager_->db_disabled_ = db_disabled_;
-    callback_->Run(db_disabled_ ? kQuotaErrorInvalidAccess : kQuotaStatusOk,
-                   new_quota_);
-  }
-
- private:
-  QuotaManager* manager_;
-  QuotaDatabase* database_;
-  int64 new_quota_;
-  scoped_ptr<QuotaCallback> callback_;
-  bool db_disabled_;
-};
-
-class QuotaManager::PersistentHostQuotaQueryTask : public QuotaThreadTask {
- public:
-  PersistentHostQuotaQueryTask(
-      QuotaManager* manager,
-      QuotaDatabase* database,
-      scoped_refptr<base::MessageLoopProxy> db_message_loop,
-      const std::string& host,
-      HostQuotaCallback* callback)
-      : QuotaThreadTask(manager, db_message_loop),
-        manager_(manager),
-        database_(database),
-        host_(host),
-        quota_(-1),
-        callback_(callback) {
-    DCHECK(manager_);
-    DCHECK(database_);
-    DCHECK(!host_.empty());
-  }
- protected:
-  virtual void RunOnTargetThread() OVERRIDE {
-    if (!database_->GetHostQuota(host_, kStorageTypePersistent, &quota_))
-      quota_ = 0;
-  }
-  virtual void Completed() OVERRIDE {
-    callback_->Run(kQuotaStatusOk, host_, quota_);
-  }
- private:
-  QuotaManager* manager_;
-  QuotaDatabase* database_;
-  std::string host_;
-  int64 quota_;
-  scoped_ptr<HostQuotaCallback> callback_;
-};
-
-class QuotaManager::PersistentHostQuotaUpdateTask : public QuotaThreadTask {
- public:
-  PersistentHostQuotaUpdateTask(
-      QuotaManager* manager,
-      QuotaDatabase* database,
-      scoped_refptr<base::MessageLoopProxy> db_message_loop,
-      const std::string& host,
-      int new_quota,
-      HostQuotaCallback* callback)
-      : QuotaThreadTask(manager, db_message_loop),
-        manager_(manager),
-        database_(database),
-        host_(host),
-        new_quota_(new_quota),
-        callback_(callback),
-        db_disabled_(false) {
-    DCHECK(manager_);
-    DCHECK(database_);
-    DCHECK(!host_.empty());
-    DCHECK(new_quota_ >= 0);
-  }
- protected:
-  virtual void RunOnTargetThread() OVERRIDE {
-    if (!database_->SetHostQuota(host_, kStorageTypePersistent, new_quota_)) {
-      db_disabled_ = true;
-      new_quota_ = 0;
-    }
   }
 
-  virtual void Completed() OVERRIDE {
-    manager_->db_disabled_ = db_disabled_;
-    callback_->Run(db_disabled_ ? kQuotaErrorInvalidAccess : kQuotaStatusOk,
-                   host_, new_quota_);
-  }
  private:
   QuotaManager* manager_;
   QuotaDatabase* database_;
-  std::string host_;
   int64 new_quota_;
-  scoped_ptr<HostQuotaCallback> callback_;
   bool db_disabled_;
 };
 
@@ -504,7 +411,7 @@ void QuotaManager::GetTemporaryGlobalQuota(QuotaCallback* callback) {
   if (temporary_global_quota_ >= 0) {
     // TODO(kinuko): The in-memory quota value should be periodically
     // updated not to exceed the current available space in the hard drive.
-    callback->Run(kQuotaStatusOk, temporary_global_quota_);
+    callback->Run(temporary_global_quota_);
     delete callback;
     return;
   }
@@ -512,58 +419,41 @@ void QuotaManager::GetTemporaryGlobalQuota(QuotaCallback* callback) {
   temporary_global_quota_callbacks_.Add(callback);
 }
 
-void QuotaManager::SetTemporaryGlobalQuota(int64 new_quota,
-                                           QuotaCallback* callback) {
+void QuotaManager::SetTemporaryGlobalQuota(int64 new_quota) {
   LazyInitialize();
-  if (new_quota < 0) {
-    callback->Run(kQuotaErrorInvalidModification, -1);
-    delete callback;
-    return;
-  }
-
+  DCHECK(new_quota >= 0);
   DidGetTemporaryGlobalQuota(new_quota);
   if (!db_disabled_) {
     scoped_refptr<TemporaryGlobalQuotaUpdateTask> task(
         new TemporaryGlobalQuotaUpdateTask(
-            this, database_.get(), db_thread_, new_quota, callback));
+            this, database_.get(), db_thread_, new_quota));
     task->Start();
-  } else {
-    callback->Run(kQuotaErrorInvalidAccess, -1);
-    delete callback;
   }
 }
 
 void QuotaManager::GetPersistentHostQuota(const std::string& host,
                                           HostQuotaCallback* callback) {
   LazyInitialize();
-
-  scoped_refptr<PersistentHostQuotaQueryTask> task(
-      new PersistentHostQuotaQueryTask(
-          this, database_.get(), db_thread_, host, callback));
-  task->Start();
-}
-
-void QuotaManager::SetPersistentHostQuota(const std::string& host,
-                                          int64 new_quota,
-                                          HostQuotaCallback* callback) {
-  LazyInitialize();
-  if (new_quota < 0) {
-    callback->Run(kQuotaErrorInvalidModification, host, -1);
+  std::map<std::string, int64>::iterator found =
+      persistent_host_quota_.find(host);
+  if (found != persistent_host_quota_.end()) {
+    callback->Run(host, found->second);
     delete callback;
     return;
   }
-
-  if (!db_disabled_) {
-    scoped_refptr<PersistentHostQuotaUpdateTask> task(
-        new PersistentHostQuotaUpdateTask(
-            this, database_.get(), db_thread_, host, new_quota, callback));
-    task->Start();
-  } else {
-    callback->Run(kQuotaErrorInvalidAccess, host, -1);
-    delete callback;
+  if (persistent_host_quota_callbacks_.Add(host, callback)) {
+    // This is the first call for this host.
+    // TODO(kinuko): Dispatch a task to get the host quota for the host
+    // once QuotaDatabase is updated to accept hosts instead of origins.
   }
 }
 
+void QuotaManager::SetPersistentHostQuota(const std::string& host,
+                                          int64 new_quota) {
+  LazyInitialize();
+  // TODO(kinuko): Implement once QuotaDatabase is updated.
+}
+
 void QuotaManager::LazyInitialize() {
   DCHECK(io_thread_->BelongsToCurrentThread());
   if (database_.get()) {
@@ -615,9 +505,14 @@ UsageTracker* QuotaManager::GetUsageTracker(StorageType type) const {
 
 void QuotaManager::DidGetTemporaryGlobalQuota(int64 quota) {
   temporary_global_quota_ = quota;
-  temporary_global_quota_callbacks_.Run(
-      db_disabled_ ? kQuotaErrorInvalidAccess : kQuotaStatusOk,
-      quota);
+  temporary_global_quota_callbacks_.Run(quota);
+}
+
+void QuotaManager::DidGetPersistentHostQuota(const std::string& host,
+                                             int64 quota) {
+  DCHECK(persistent_host_quota_.find(host) == persistent_host_quota_.end());
+  persistent_host_quota_[host] = quota;
+  persistent_host_quota_callbacks_.Run(host, host, quota);
 }
 
 void QuotaManager::DeleteOnCorrectThread() const {
@@ -628,131 +523,6 @@ void QuotaManager::DeleteOnCorrectThread() const {
   delete this;
 }
 
-class QuotaManager::GlobalUsageQueryTask : public QuotaTask {
- public:
-  GlobalUsageQueryTask(QuotaManager* manager,
-                       StorageType type,
-                       UsageCallback* callback)
-      : QuotaTask(manager),
-        manager_(manager),
-        callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
-        type_(type),
-        usage_(0),
-        callback_(callback) {}
-
- protected:
-  virtual void Run() OVERRIDE {
-    UsageTracker* tracker = NULL;
-
-    switch (type_) {
-      case kStorageTypeTemporary:
-        tracker = manager_->temporary_usage_tracker_.get();
-        break;
-      case kStorageTypePersistent:
-        tracker = manager_->persistent_usage_tracker_.get();
-        break;
-      default:
-        NOTREACHED();
-    }
-
-    DCHECK(tracker);
-    tracker->GetGlobalUsage(
-        callback_factory_.NewCallback(
-            &GlobalUsageQueryTask::DidGetGlobalUsage));
-  }
-
-  virtual void Aborted() OVERRIDE {
-    delete this;
-  }
-
-  virtual void Completed() OVERRIDE {
-    callback_->Run(usage_);
-    delete this;
-  }
- private:
-  QuotaManager* manager_;
-  ScopedCallbackFactory<GlobalUsageQueryTask> callback_factory_;
-  StorageType type_;
-  int64 usage_;
-  UsageCallback* callback_;
-
-  void DidGetGlobalUsage(int64 usage) {
-    usage_ += usage;
-    CallCompleted();
-  }
-};
-
-class QuotaManager::HostUsageQueryTask : public QuotaTask {
- public:
-  HostUsageQueryTask(QuotaManager* manager,
-                     const std::string& host,
-                     StorageType type,
-                     HostUsageCallback* callback)
-      : QuotaTask(manager),
-        manager_(manager),
-        callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
-        usage_(0),
-        host_(host),
-        type_(type),
-        callback_(callback) {}
-
- protected:
-  virtual void Run() OVERRIDE {
-    UsageTracker* tracker = NULL;
-    switch (type_) {
-      case kStorageTypeTemporary:
-        tracker = manager_->temporary_usage_tracker_.get();
-        break;
-      case kStorageTypePersistent:
-        tracker = manager_->persistent_usage_tracker_.get();
-        break;
-      default:
-        NOTREACHED();
-    }
-
-    DCHECK(tracker);
-    tracker->GetHostUsage(
-        host_,
-        callback_factory_.NewCallback(
-            &HostUsageQueryTask::DidGetHostUsage));
-  }
-
-  virtual void Aborted() OVERRIDE {
-    delete this;
-  }
-
-  virtual void Completed() OVERRIDE {
-    callback_->Run(host_, usage_);
-    delete this;
-  }
- private:
-  QuotaManager* manager_;
-  ScopedCallbackFactory<HostUsageQueryTask> callback_factory_;
-  int task_count_;
-  int64 usage_;
-  std::string host_;
-  StorageType type_;
-  HostUsageCallback* callback_;
-
-  void DidGetHostUsage(const std::string&, int64 usage) {
-    usage_ = usage;
-    CallCompleted();
-  }
-};
-
-void QuotaManager::GetGlobalUsage(StorageType type, UsageCallback* callback){
-  LazyInitialize();
-  QuotaTask* task = new GlobalUsageQueryTask(this, type, callback);
-  task->Start();
-}
-
-void QuotaManager::GetHostUsage(const std::string& host, StorageType type,
-                                HostUsageCallback* callback) {
-  LazyInitialize();
-  QuotaTask* task = new HostUsageQueryTask(this, host, type, callback);
-  task->Start();
-}
-
 // QuotaManagerProxy ----------------------------------------------------------
 
 void QuotaManagerProxy::GetUsageAndQuota(
diff --git a/webkit/quota/quota_manager.h b/webkit/quota/quota_manager.h
index d54336f..16c0588 100644
--- a/webkit/quota/quota_manager.h
+++ b/webkit/quota/quota_manager.h
@@ -67,16 +67,14 @@ class QuotaManager : public QuotaTaskObserver,
 
   // Called by UI and internal modules.
   void GetTemporaryGlobalQuota(QuotaCallback* callback);
-  void SetTemporaryGlobalQuota(int64 new_quota, QuotaCallback* callback);
+  void SetTemporaryGlobalQuota(int64 new_quota);
   void GetPersistentHostQuota(const std::string& host,
                               HostQuotaCallback* callback);
-  void SetPersistentHostQuota(const std::string& host,
-                              int64 new_quota,
-                              HostQuotaCallback* callback);
+  void SetPersistentHostQuota(const std::string& host, int64 new_quota);
 
-  void GetGlobalUsage(StorageType type, UsageCallback* callback);
-  void GetHostUsage(const std::string& host, StorageType type,
-                    HostUsageCallback* callback);
+  // TODO(kinuko): Add more APIs for UI:
+  // - Get temporary global/per-host usage
+  // - Get persistent global/per-host usage
 
   const static int64 kTemporaryStorageQuotaDefaultSize;
   const static int64 kTemporaryStorageQuotaMaxSize;
@@ -87,16 +85,11 @@ class QuotaManager : public QuotaTaskObserver,
  private:
   class InitializeTask;
   class TemporaryGlobalQuotaUpdateTask;
-  class PersistentHostQuotaUpdateTask;
-  class PersistentHostQuotaQueryTask;
 
   class UsageAndQuotaDispatcherTask;
   class UsageAndQuotaDispatcherTaskForTemporary;
   class UsageAndQuotaDispatcherTaskForPersistent;
 
-  class GlobalUsageQueryTask;
-  class HostUsageQueryTask;
-
   typedef std::pair<std::string, StorageType> HostAndType;
   typedef std::map<HostAndType, UsageAndQuotaDispatcherTask*>
       UsageAndQuotaDispatcherTaskMap;
@@ -126,6 +119,7 @@ class QuotaManager : public QuotaTaskObserver,
   UsageTracker* GetUsageTracker(StorageType type) const;
 
   void DidGetTemporaryGlobalQuota(int64 quota);
+  void DidGetPersistentHostQuota(const std::string& host, int64 quota);
 
   void DeleteOnCorrectThread() const;
 
@@ -149,6 +143,9 @@ class QuotaManager : public QuotaTaskObserver,
   int64 temporary_global_quota_;
   QuotaCallbackQueue temporary_global_quota_callbacks_;
 
+  std::map<std::string, int64> persistent_host_quota_;
+  HostQuotaCallbackMap persistent_host_quota_callbacks_;
+
   DISALLOW_COPY_AND_ASSIGN(QuotaManager);
 };
 
diff --git a/webkit/quota/quota_manager_unittest.cc b/webkit/quota/quota_manager_unittest.cc
index d931cab..eb0af8f 100644
--- a/webkit/quota/quota_manager_unittest.cc
+++ b/webkit/quota/quota_manager_unittest.cc
@@ -72,7 +72,7 @@ class QuotaManagerTest : public testing::Test {
   }
 
   void GetUsageAndQuota(const GURL& origin, StorageType type) {
-    quota_status_ = kQuotaStatusUnknown;
+    status_ = kQuotaStatusUnknown;
     usage_ = -1;
     quota_ = -1;
     quota_manager_->GetUsageAndQuota(origin, type,
@@ -80,52 +80,6 @@ class QuotaManagerTest : public testing::Test {
             &QuotaManagerTest::DidGetUsageAndQuota));
   }
 
-  void GetTemporaryGlobalQuota() {
-    quota_status_ = kQuotaStatusUnknown;
-    quota_ = -1;
-    quota_manager_->GetTemporaryGlobalQuota(
-        callback_factory_.NewCallback(
-            &QuotaManagerTest::DidGetQuota));
-  }
-
-  void SetTemporaryGlobalQuota(int64 new_quota) {
-    quota_status_ = kQuotaStatusUnknown;
-    quota_ = -1;
-    quota_manager_->SetTemporaryGlobalQuota(new_quota,
-        callback_factory_.NewCallback(
-            &QuotaManagerTest::DidGetQuota));
-  }
-
-  void GetPersistentHostQuota(const std::string& host) {
-    quota_status_ = kQuotaStatusUnknown;
-    quota_ = -1;
-    quota_manager_->GetPersistentHostQuota(host,
-        callback_factory_.NewCallback(
-            &QuotaManagerTest::DidGetHostQuota));
-  }
-
-  void SetPersistentHostQuota(const std::string& host, int64 new_quota) {
-    quota_status_ = kQuotaStatusUnknown;
-    quota_ = -1;
-    quota_manager_->SetPersistentHostQuota(host, new_quota,
-        callback_factory_.NewCallback(
-            &QuotaManagerTest::DidGetHostQuota));
-  }
-
-  void GetGlobalUsage(StorageType type) {
-    usage_ = -1;
-    quota_manager_->GetGlobalUsage(type,
-        callback_factory_.NewCallback(
-            &QuotaManagerTest::DidGetGlobalUsage));
-  }
-
-  void GetHostUsage(const std::string& host, StorageType type) {
-    usage_ = -1;
-    quota_manager_->GetHostUsage(host, type,
-        callback_factory_.NewCallback(
-            &QuotaManagerTest::DidGetHostUsage));
-  }
-
   void RunAdditionalUsageAndQuotaTask(const GURL& origin, StorageType type) {
     quota_manager_->GetUsageAndQuota(origin, type,
         callback_factory_.NewCallback(
@@ -133,31 +87,11 @@ class QuotaManagerTest : public testing::Test {
   }
 
   void DidGetUsageAndQuota(QuotaStatusCode status, int64 usage, int64 quota) {
-    quota_status_ = status;
+    status_ = status;
     usage_ = usage;
     quota_ = quota;
   }
 
-  void DidGetQuota(QuotaStatusCode status, int64 quota) {
-    quota_status_ = status;
-    quota_ = quota;
-  }
-
-  void DidGetHostQuota(QuotaStatusCode status,
-                       const std::string& host, int64 quota) {
-    quota_status_ = status;
-    host_ = host;
-    quota_ = quota;
-  }
-
-  void DidGetGlobalUsage(int64 usage) {
-    usage_ = usage;
-  }
-
-  void DidGetHostUsage(const std::string&, int64 usage) {
-    usage_ = usage;
-  }
-
   void set_additional_callback_count(int c) { additional_callback_count_ = c; }
   int additional_callback_count() const { return additional_callback_count_; }
   void DidGetUsageAndQuotaAdditional(
@@ -170,7 +104,7 @@ class QuotaManagerTest : public testing::Test {
     quota_manager_ = quota_manager;
   }
 
-  QuotaStatusCode status() const { return quota_status_; }
+  QuotaStatusCode status() const { return status_; }
   int64 usage() const { return usage_; }
   int64 quota() const { return quota_; }
 
@@ -180,8 +114,7 @@ class QuotaManagerTest : public testing::Test {
 
   scoped_refptr<QuotaManager> quota_manager_;
 
-  QuotaStatusCode quota_status_;
-  std::string host_;
+  QuotaStatusCode status_;
   int64 usage_;
   int64 quota_;
 
@@ -190,25 +123,19 @@ class QuotaManagerTest : public testing::Test {
   DISALLOW_COPY_AND_ASSIGN(QuotaManagerTest);
 };
 
-TEST_F(QuotaManagerTest, GetUsageAndQuota_Simple) {
+TEST_F(QuotaManagerTest, GetTemporaryUsageAndQuota_Simple) {
   const static MockOriginData kData[] = {
     { "http://foo.com/",     kStorageTypeTemporary,  10 },
     { "http://foo.com/",     kStorageTypePersistent, 80 },
   };
   RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData)));
 
-  GetUsageAndQuota(GURL("http://foo.com/"), kStorageTypePersistent);
-  MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(kQuotaStatusOk, status());
-  EXPECT_EQ(80, usage());
-  EXPECT_EQ(0, quota());
-
   GetUsageAndQuota(GURL("http://foo.com/"), kStorageTypeTemporary);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(10, usage());
-  EXPECT_LE(0, quota());
-  EXPECT_GE(QuotaManager::kTemporaryStorageQuotaMaxSize, quota());
+  EXPECT_GT(quota(), 0);
+  EXPECT_LE(quota(), QuotaManager::kTemporaryStorageQuotaMaxSize);
   int64 quota_returned_for_foo = quota();
 
   GetUsageAndQuota(GURL("http://bar.com/"), kStorageTypeTemporary);
@@ -218,61 +145,19 @@ TEST_F(QuotaManagerTest, GetUsageAndQuota_Simple) {
   EXPECT_EQ(quota_returned_for_foo - 10, quota());
 }
 
-TEST_F(QuotaManagerTest, GetUsage_NoClient) {
+TEST_F(QuotaManagerTest, GetTemporaryUsage_NoClient) {
   GetUsageAndQuota(GURL("http://foo.com/"), kStorageTypeTemporary);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(0, usage());
-
-  GetUsageAndQuota(GURL("http://foo.com/"), kStorageTypePersistent);
-  MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(kQuotaStatusOk, status());
-  EXPECT_EQ(0, usage());
-
-  GetHostUsage("foo.com", kStorageTypeTemporary);
-  MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(0, usage());
-
-  GetHostUsage("foo.com", kStorageTypePersistent);
-  MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(0, usage());
-
-  GetGlobalUsage(kStorageTypeTemporary);
-  MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(0, usage());
-
-  GetGlobalUsage(kStorageTypePersistent);
-  MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(0, usage());
 }
 
-TEST_F(QuotaManagerTest, GetUsage_EmptyClient) {
+TEST_F(QuotaManagerTest, GetTemporaryUsage_EmptyClient) {
   RegisterClient(CreateClient(NULL, 0));
   GetUsageAndQuota(GURL("http://foo.com/"), kStorageTypeTemporary);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(0, usage());
-
-  GetUsageAndQuota(GURL("http://foo.com/"), kStorageTypePersistent);
-  MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(kQuotaStatusOk, status());
-  EXPECT_EQ(0, usage());
-
-  GetHostUsage("foo.com", kStorageTypeTemporary);
-  MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(0, usage());
-
-  GetHostUsage("foo.com", kStorageTypePersistent);
-  MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(0, usage());
-
-  GetGlobalUsage(kStorageTypeTemporary);
-  MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(0, usage());
-
-  GetGlobalUsage(kStorageTypePersistent);
-  MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(0, usage());
 }
 
 TEST_F(QuotaManagerTest, GetTemporaryUsageAndQuota_MultiOrigins) {
@@ -287,10 +172,7 @@ TEST_F(QuotaManagerTest, GetTemporaryUsageAndQuota_MultiOrigins) {
   RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData)));
 
   // This time explicitly sets a temporary global quota.
-  SetTemporaryGlobalQuota(100);
-  MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(kQuotaStatusOk, status());
-  EXPECT_EQ(100, quota());
+  quota_manager()->SetTemporaryGlobalQuota(100);
 
   GetUsageAndQuota(GURL("http://foo.com/"), kStorageTypeTemporary);
   MessageLoop::current()->RunAllPending();
@@ -307,11 +189,10 @@ TEST_F(QuotaManagerTest, GetTemporaryUsageAndQuota_MultiOrigins) {
   EXPECT_EQ(100 - (10 + 20 + 30), quota());
 }
 
-TEST_F(QuotaManagerTest, GetUsage_MultipleClients) {
+TEST_F(QuotaManagerTest, GetTemporaryUsage_MultipleClients) {
   const static MockOriginData kData1[] = {
     { "http://foo.com/",     kStorageTypeTemporary,  10 },
     { "http://bar.com/",     kStorageTypeTemporary,  20 },
-    { "http://bar.com/",     kStorageTypePersistent, 50 },
   };
   const static MockOriginData kData2[] = {
     { "https://foo.com/",    kStorageTypeTemporary,  30 },
@@ -324,21 +205,6 @@ TEST_F(QuotaManagerTest, GetUsage_MultipleClients) {
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(10 + 30, usage());
-
-  GetUsageAndQuota(GURL("http://bar.com/"), kStorageTypePersistent);
-  MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(kQuotaStatusOk, status());
-  EXPECT_EQ(50, usage());
-
-  GetGlobalUsage(kStorageTypeTemporary);
-  MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(kQuotaStatusOk, status());
-  EXPECT_EQ(10 + 20 + 30, usage());
-
-  GetGlobalUsage(kStorageTypePersistent);
-  MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(kQuotaStatusOk, status());
-  EXPECT_EQ(40 + 50, usage());
 }
 
 TEST_F(QuotaManagerTest, GetTemporaryUsage_WithModify) {
@@ -380,7 +246,7 @@ TEST_F(QuotaManagerTest, GetTemporaryUsageAndQuota_WithAdditionalTasks) {
     { "http://foo.com/",        kStorageTypePersistent, 40 },
   };
   RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData)));
-  SetTemporaryGlobalQuota(100);
+  quota_manager()->SetTemporaryGlobalQuota(100);
 
   GetUsageAndQuota(GURL("http://foo.com/"), kStorageTypeTemporary);
   GetUsageAndQuota(GURL("http://foo.com/"), kStorageTypeTemporary);
@@ -411,7 +277,7 @@ TEST_F(QuotaManagerTest, GetTemporaryUsageAndQuota_NukeManager) {
     { "http://foo.com/",        kStorageTypePersistent, 40 },
   };
   RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData)));
-  SetTemporaryGlobalQuota(100);
+  quota_manager()->SetTemporaryGlobalQuota(100);
 
   set_additional_callback_count(0);
   GetUsageAndQuota(GURL("http://foo.com/"), kStorageTypeTemporary);
@@ -426,223 +292,4 @@ TEST_F(QuotaManagerTest, GetTemporaryUsageAndQuota_NukeManager) {
   EXPECT_EQ(kQuotaErrorAbort, status());
 }
 
-TEST_F(QuotaManagerTest, GetAndSetPerststentHostQuota) {
-  RegisterClient(CreateClient(NULL, 0));
-
-  GetPersistentHostQuota("foo.com");
-  MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(0, quota());
-
-  SetPersistentHostQuota("foo.com", 100);
-  MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(100, quota());
-
-  GetPersistentHostQuota("foo.com");
-  SetPersistentHostQuota("foo.com", 200);
-  GetPersistentHostQuota("foo.com");
-  SetPersistentHostQuota("foo.com", 300);
-  GetPersistentHostQuota("foo.com");
-  MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(300, quota());
-}
-
-TEST_F(QuotaManagerTest, GetAndSetPersistentUsageAndQuota) {
-  RegisterClient(CreateClient(NULL, 0));
-
-  GetUsageAndQuota(GURL("http://foo.com/"), kStorageTypePersistent);
-  MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(kQuotaStatusOk, status());
-  EXPECT_EQ(0, usage());
-  EXPECT_EQ(0, quota());
-
-  SetPersistentHostQuota("foo.com",100);
-  GetUsageAndQuota(GURL("http://foo.com/"), kStorageTypePersistent);
-  MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(kQuotaStatusOk, status());
-  EXPECT_EQ(0, usage());
-  EXPECT_EQ(100, quota());
-}
-
-TEST_F(QuotaManagerTest, GetPersistentUsageAndQuota_MultiOrigins) {
-  const static MockOriginData kData[] = {
-    { "http://foo.com/",        kStorageTypePersistent, 10 },
-    { "http://foo.com:8080/",   kStorageTypePersistent, 20 },
-    { "https://foo.com/",       kStorageTypePersistent, 13 },
-    { "https://foo.com:8081/",  kStorageTypePersistent, 19 },
-    { "http://bar.com/",        kStorageTypePersistent,  5 },
-    { "https://bar.com/",       kStorageTypePersistent,  7 },
-    { "http://baz.com/",        kStorageTypePersistent, 30 },
-    { "http://foo.com/",        kStorageTypeTemporary,  40 },
-  };
-  RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData)));
-
-  SetPersistentHostQuota("foo.com", 100);
-  GetUsageAndQuota(GURL("http://foo.com/"), kStorageTypePersistent);
-  MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(kQuotaStatusOk, status());
-  EXPECT_EQ(10 + 20 + 13 + 19, usage());
-  EXPECT_EQ(100, quota());
-}
-
-TEST_F(QuotaManagerTest, GetPersistentUsage_WithModify) {
-  const static MockOriginData kData[] = {
-    { "http://foo.com/",     kStorageTypePersistent,  10 },
-    { "http://foo.com:1/",   kStorageTypePersistent,  20 },
-  };
-  MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData));
-  RegisterClient(client);
-
-  GetUsageAndQuota(GURL("http://foo.com/"), kStorageTypePersistent);
-  MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(kQuotaStatusOk, status());
-  EXPECT_EQ(10 + 20, usage());
-
-  client->ModifyMockOriginDataSize(
-      GURL("http://foo.com/"), kStorageTypePersistent, 20);
-  client->ModifyMockOriginDataSize(
-      GURL("http://foo.com:1/"), kStorageTypePersistent, -5);
-  client->ModifyMockOriginDataSize(
-      GURL("http://bar.com/"), kStorageTypePersistent, 33);
-
-  GetUsageAndQuota(GURL("http://foo.com/"), kStorageTypePersistent);
-  MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(kQuotaStatusOk, status());
-  EXPECT_EQ(10 + 20 + 20 - 5, usage());
-
-  GetUsageAndQuota(GURL("http://bar.com/"), kStorageTypePersistent);
-  MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(kQuotaStatusOk, status());
-  EXPECT_EQ(33, usage());
-}
-
-TEST_F(QuotaManagerTest, GetPersistentUsageAndQuota_WithAdditionalTasks) {
-  const static MockOriginData kData[] = {
-    { "http://foo.com/",        kStorageTypePersistent,  10 },
-    { "http://foo.com:8080/",   kStorageTypePersistent,  20 },
-    { "http://bar.com/",        kStorageTypePersistent,  13 },
-    { "http://foo.com/",        kStorageTypeTemporary,   40 },
-  };
-  RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData)));
-  SetPersistentHostQuota("foo.com",100);
-
-  GetUsageAndQuota(GURL("http://foo.com/"), kStorageTypePersistent);
-  GetUsageAndQuota(GURL("http://foo.com/"), kStorageTypePersistent);
-  GetUsageAndQuota(GURL("http://foo.com/"), kStorageTypePersistent);
-  MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(kQuotaStatusOk, status());
-  EXPECT_EQ(10 + 20, usage());
-  EXPECT_EQ(100, quota());
-
-  set_additional_callback_count(0);
-  RunAdditionalUsageAndQuotaTask(GURL("http://foo.com/"),
-                                 kStorageTypePersistent);
-  GetUsageAndQuota(GURL("http://foo.com/"), kStorageTypePersistent);
-  RunAdditionalUsageAndQuotaTask(GURL("http://bar.com/"),
-                                 kStorageTypePersistent);
-  MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(kQuotaStatusOk, status());
-  EXPECT_EQ(10 + 20, usage());
-  EXPECT_EQ(2, additional_callback_count());
-}
-
-TEST_F(QuotaManagerTest, GetPersistentUsageAndQuota_NukeManager) {
-  const static MockOriginData kData[] = {
-    { "http://foo.com/",        kStorageTypePersistent,  10 },
-    { "http://foo.com:8080/",   kStorageTypePersistent,  20 },
-    { "http://bar.com/",        kStorageTypePersistent,  13 },
-    { "http://foo.com/",        kStorageTypeTemporary,   40 },
-  };
-  RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData)));
-  SetPersistentHostQuota("foo.com", 100);
-
-  set_additional_callback_count(0);
-  GetUsageAndQuota(GURL("http://foo.com/"), kStorageTypePersistent);
-  RunAdditionalUsageAndQuotaTask(GURL("http://foo.com/"),
-                                 kStorageTypePersistent);
-  RunAdditionalUsageAndQuotaTask(GURL("http://bar.com/"),
-                                 kStorageTypePersistent);
-
-  // Nuke before waiting for callbacks.
-  set_quota_manager(NULL);
-  MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(kQuotaErrorAbort, status());
-}
-
-TEST_F(QuotaManagerTest, GetUsage_Simple) {
-  const static MockOriginData kData[] = {
-    { "http://foo.com/",   kStorageTypePersistent,       1 },
-    { "http://foo.com:1/", kStorageTypePersistent,      20 },
-    { "http://bar.com/",   kStorageTypeTemporary,      300 },
-    { "https://buz.com/",  kStorageTypeTemporary,     4000 },
-    { "http://buz.com/",   kStorageTypeTemporary,    50000 },
-    { "http://bar.com:1/", kStorageTypePersistent,  600000 },
-    { "http://foo.com/",   kStorageTypeTemporary,  7000000 },
-  };
-  RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData)));
-
-  GetGlobalUsage(kStorageTypePersistent);
-  MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(usage(), 1 + 20 + 600000);
-
-  GetGlobalUsage(kStorageTypeTemporary);
-  MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(usage(), 300 + 4000 + 50000 + 7000000);
-
-  GetHostUsage("foo.com", kStorageTypePersistent);
-  MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(usage(), 1 + 20);
-
-  GetHostUsage("buz.com", kStorageTypeTemporary);
-  MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(usage(), 4000 + 50000);
-}
-
-TEST_F(QuotaManagerTest, GetUsage_WithModification) {
-  const static MockOriginData kData[] = {
-    { "http://foo.com/",   kStorageTypePersistent,       1 },
-    { "http://foo.com:1/", kStorageTypePersistent,      20 },
-    { "http://bar.com/",   kStorageTypeTemporary,      300 },
-    { "https://buz.com/",  kStorageTypeTemporary,     4000 },
-    { "http://buz.com/",   kStorageTypeTemporary,    50000 },
-    { "http://bar.com:1/", kStorageTypePersistent,  600000 },
-    { "http://foo.com/",   kStorageTypeTemporary,  7000000 },
-  };
-
-  MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData));
-  RegisterClient(client);
-
-  GetGlobalUsage(kStorageTypePersistent);
-  MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(usage(), 1 + 20 + 600000);
-
-  client->ModifyMockOriginDataSize(
-      GURL("http://foo.com/"), kStorageTypePersistent, 80000000);
-
-  GetGlobalUsage(kStorageTypePersistent);
-  MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(usage(), 1 + 20 + 600000 + 80000000);
-
-  GetGlobalUsage(kStorageTypeTemporary);
-  MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(usage(), 300 + 4000 + 50000 + 7000000);
-
-  client->ModifyMockOriginDataSize(
-      GURL("http://foo.com/"), kStorageTypeTemporary, 1);
-
-  GetGlobalUsage(kStorageTypeTemporary);
-  MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(usage(), 300 + 4000 + 50000 + 7000000 + 1);
-
-  GetHostUsage("buz.com", kStorageTypeTemporary);
-  MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(usage(), 4000 + 50000);
-
-  client->ModifyMockOriginDataSize(
-      GURL("http://buz.com/"), kStorageTypeTemporary, 900000000);
-
-  GetHostUsage("buz.com", kStorageTypeTemporary);
-  MessageLoop::current()->RunAllPending();
-  EXPECT_EQ(usage(), 4000 + 50000 + 900000000);
-}
-
 }  // namespace quota
diff --git a/webkit/quota/quota_types.h b/webkit/quota/quota_types.h
index f4d7d26..2d42440 100644
--- a/webkit/quota/quota_types.h
+++ b/webkit/quota/quota_types.h
@@ -22,26 +22,19 @@ enum StorageType {
   kStorageTypeUnknown,
 };
 
-// TODO(tzik): Add assertions to
-// content/browser/renderer_host/quota_dispatcher_host.cc
-// ref) third_party/WebKit/Source/WebCore/dom/ExceptionCode.h,
 enum QuotaStatusCode {
   kQuotaStatusOk = 0,
-  kQuotaErrorNotSupported = 9,         // NOT_SUPPORTED_ERR
-  kQuotaErrorInvalidModification = 13, // INVALID_MODIFICATION_ERR
-  kQuotaErrorInvalidAccess = 15,       // INVALID_ACCESS_ERR
-  kQuotaErrorAbort = 20,               // ABORT_ERR
+  kQuotaErrorNotSupported = 9,
+  kQuotaErrorAbort = 20,
   kQuotaStatusUnknown = -1,
 };
 
 // Common callback types that are used throughout in the quota module.
 typedef Callback1<int64>::Type UsageCallback;
-typedef Callback2<QuotaStatusCode,
-                  int64>::Type QuotaCallback;
+typedef Callback1<int64>::Type QuotaCallback;
 typedef Callback2<const std::string& /* host */,
                   int64>::Type HostUsageCallback;
-typedef Callback3<QuotaStatusCode,
-                  const std::string& /* host */,
+typedef Callback2<const std::string& /* host */,
                   int64>::Type HostQuotaCallback;
 
 // Simple template wrapper for a callback queue.
@@ -100,24 +93,8 @@ class CallbackQueue2 : public CallbackQueueBase<CallbackType2> {
   }
 };
 
-template <typename CallbackType3, typename A1, typename A2, typename A3>
-class CallbackQueue3 : public CallbackQueueBase<CallbackType3> {
- public:
-  typedef typename CallbackQueueBase<CallbackType3>::Queue Queue;
-  // Runs the callbacks added to the queue and clears the queue.
-  void Run(A1 arg1, A2 arg2, A3 arg3) {
-    for (typename Queue::iterator iter = this->callbacks_.begin();
-         iter != this->callbacks_.end(); ++iter) {
-      (*iter)->Run(arg1, arg2, arg3);
-      delete *iter;
-    }
-    this->callbacks_.clear();
-  }
-};
-
 typedef CallbackQueue1<UsageCallback*, int64> UsageCallbackQueue;
-typedef CallbackQueue2<QuotaCallback*,
-                       QuotaStatusCode, int64> QuotaCallbackQueue;
+typedef CallbackQueue1<QuotaCallback*, int64> QuotaCallbackQueue;
 
 template <typename CallbackType, typename CallbackQueueType, typename KEY>
 class CallbackQueueMapBase {
@@ -188,35 +165,9 @@ class CallbackQueueMap2
   }
 };
 
-template <typename CallbackType3, typename KEY,
-          typename ARG1, typename ARG2, typename ARG3>
-class CallbackQueueMap3
-    : public CallbackQueueMapBase<CallbackType3,
-                                  CallbackQueue3<CallbackType3,
-                                                 ARG1, ARG2, ARG3>,
-                                  KEY> {
- public:
-  typedef typename CallbackQueueMapBase<
-      CallbackType3,
-      CallbackQueue3<CallbackType3, ARG1, ARG2, ARG3>,
-      KEY>::iterator iterator;
-  typedef CallbackQueue3<CallbackType3, ARG1, ARG2, ARG3> Queue;
-
-  // Runs the callbacks added for the given |key| and clears the key
-  // from the map.
-  void Run(const KEY& key, ARG1 arg1, ARG2 arg2, ARG3 arg3) {
-    if (!this->HasCallbacks(key))
-      return;
-    Queue& queue = this->callback_map_[key];
-    queue.Run(arg1, arg2, arg3);
-    this->callback_map_.erase(key);
-  }
-};
-
 typedef CallbackQueueMap2<HostUsageCallback*, std::string,
                           const std::string&, int64> HostUsageCallbackMap;
-typedef CallbackQueueMap3<HostQuotaCallback*, std::string,
-                          QuotaStatusCode,
+typedef CallbackQueueMap2<HostUsageCallback*, std::string,
                           const std::string&, int64> HostQuotaCallbackMap;
 
 }  // namespace quota