QuotaManager::DeleteOriginData now allows deletion of specific QuotaClients

webkit/quota/quota_manager.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/quota/quota_manager.h"
 
 #include <algorithm>
 #include <deque>
 #include <set>
 
@@ skipping 361 matching lines @@
       NOTREACHED();
   }
   return NULL;
 }
 
 class QuotaManager::OriginDataDeleter : public QuotaTask {
  public:
   OriginDataDeleter(QuotaManager* manager,
                     const GURL& origin,
                     StorageType type,
+                    int quota_client_mask,
                     StatusCallback* callback)
       : QuotaTask(manager),
         origin_(origin),
         type_(type),
+        quota_client_mask_(quota_client_mask),
         error_count_(0),
         remaining_clients_(-1),
+        skipped_clients_(0),
         callback_(callback),
         callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {}
 
  protected:
   virtual void Run() OVERRIDE {
     error_count_ = 0;
     remaining_clients_ = manager()->clients_.size();
     for (QuotaClientList::iterator iter = manager()->clients_.begin();
          iter != manager()->clients_.end(); ++iter) {
-      (*iter)->DeleteOriginData(origin_, type_, callback_factory_.NewCallback(
-          &OriginDataDeleter::DidDeleteOriginData));
+      if (quota_client_mask_ & (*iter)->id()) {
+        (*iter)->DeleteOriginData(origin_, type_, callback_factory_.NewCallback(
+            &OriginDataDeleter::DidDeleteOriginData));
+      } else {
+        ++skipped_clients_;
+        if (--remaining_clients_ == 0)
+          CallCompleted();
+      }
     }
   }
 
   virtual void Completed() OVERRIDE {
     if (error_count_ == 0) {
-      manager()->DeleteOriginFromDatabase(origin_, type_);
+      if (remaining_clients_ == 0)
+        manager()->DeleteOriginFromDatabase(origin_, type_);
       callback_->Run(kQuotaStatusOk);
     } else {
       callback_->Run(kQuotaErrorInvalidModification);
     }
     DeleteSoon();
   }
 
   virtual void Aborted() OVERRIDE {
     callback_->Run(kQuotaErrorAbort);
     DeleteSoon();
   }
 
   void DidDeleteOriginData(QuotaStatusCode status) {
     DCHECK_GT(remaining_clients_, 0);
 
     if (status != kQuotaStatusOk)
       ++error_count_;
 
     if (--remaining_clients_ == 0)
       CallCompleted();
   }
 
   QuotaManager* manager() const {
     return static_cast<QuotaManager*>(observer());
   }
 
   GURL origin_;
   StorageType type_;
+  int quota_client_mask_;
   int error_count_;
   int remaining_clients_;
+  int skipped_clients_;
   scoped_ptr<StatusCallback> callback_;
 
   ScopedCallbackFactory<OriginDataDeleter> callback_factory_;
   DISALLOW_COPY_AND_ASSIGN(OriginDataDeleter);
 };
 
 class QuotaManager::DatabaseTaskBase : public QuotaThreadTask {
  public:
   explicit DatabaseTaskBase(QuotaManager* manager)
       : QuotaThreadTask(manager, manager->db_thread_),
@@ skipping 714 matching lines @@
 }
 
 void QuotaManager::NotifyOriginNoLongerInUse(const GURL& origin) {
   DCHECK(io_thread_->BelongsToCurrentThread());
   DCHECK(IsOriginInUse(origin));
   int& count = origins_in_use_[origin];
   if (--count == 0)
     origins_in_use_.erase(origin);
 }
 
-void QuotaManager::DeleteOriginData(
-    const GURL& origin, StorageType type, StatusCallback* callback) {
+void QuotaManager::DeleteOriginData(const GURL& origin, StorageType type,
+    int quota_client_mask, StatusCallback* callback) {
   LazyInitialize();
 
-  if (origin.is_empty() || clients_.empty()) {
+  if (origin.is_empty() || clients_.empty() ||
+      quota_client_mask == QuotaClient::kUnknown) {
     callback->Run(kQuotaStatusOk);
     delete callback;
     return;
   }
 
   OriginDataDeleter* deleter =
-      new OriginDataDeleter(this, origin, type, callback);
+      new OriginDataDeleter(this, origin, type, quota_client_mask, callback);
   deleter->Start();
 }
 
 bool QuotaManager::ResetUsageTracker(StorageType type) {
   switch (type) {
     case kStorageTypeTemporary:
       if (temporary_usage_tracker_->IsWorking())
         return false;
       temporary_usage_tracker_.reset(
           new UsageTracker(clients_, kStorageTypeTemporary,
@@ skipping 129 matching lines @@
     const GURL& origin,
     StorageType type,
     EvictOriginDataCallback* callback) {
   DCHECK(io_thread_->BelongsToCurrentThread());
   DCHECK_EQ(type, kStorageTypeTemporary);
 
   eviction_context_.evicted_origin = origin;
   eviction_context_.evicted_type = type;
   eviction_context_.evict_origin_data_callback.reset(callback);
 
-  DeleteOriginData(origin, type, callback_factory_.NewCallback(
-      &QuotaManager::DidOriginDataEvicted));
+  DeleteOriginData(origin, type, QuotaClient::kAllClientsMask,
+      callback_factory_.NewCallback(&QuotaManager::DidOriginDataEvicted));
 }
 
 void QuotaManager::DidGetAvailableSpaceForEviction(
     QuotaStatusCode status,
     int64 available_space) {
   eviction_context_.get_usage_and_quota_callback->Run(status,
       eviction_context_.usage,
       eviction_context_.unlimited_usage,
       eviction_context_.quota, available_space);
   eviction_context_.get_usage_and_quota_callback.reset();
@@ skipping 225 matching lines @@
 
 QuotaManagerProxy::QuotaManagerProxy(
     QuotaManager* manager, base::MessageLoopProxy* io_thread)
     : manager_(manager), io_thread_(io_thread) {
 }
 
 QuotaManagerProxy::~QuotaManagerProxy() {
 }
 
 }  // namespace quota