QuotaManager::DeleteOriginData now allows deletion of specific QuotaClients

webkit/quota/quota_manager.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2012 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>
 
 #include "base/bind.h"
@@ skipping 442 matching lines @@
       NOTREACHED();
   }
   return NULL;
 }
 
 class QuotaManager::OriginDataDeleter : public QuotaTask {
  public:
   OriginDataDeleter(QuotaManager* manager,
                     const GURL& origin,
                     StorageType type,
+                    int quota_client_mask,
                     const 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),
         weak_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_,
-          base::Bind(&OriginDataDeleter::DidDeleteOriginData,
-                     weak_factory_.GetWeakPtr()));
+      if (quota_client_mask_ & (*iter)->id()) {
+        (*iter)->DeleteOriginData(
+            origin_, type_,
+            base::Bind(&OriginDataDeleter::DidDeleteOriginData,
+                       weak_factory_.GetWeakPtr()));
+      } else {
+        ++skipped_clients_;
+        if (--remaining_clients_ == 0)
+          CallCompleted();
+      }
     }
   }
 
   virtual void Completed() OVERRIDE {
     if (error_count_ == 0) {
-      manager()->DeleteOriginFromDatabase(origin_, type_);
+      // Only remove the entire origin if we didn't skip any client types.
+      if (skipped_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_;
   StatusCallback callback_;
 
   base::WeakPtrFactory<OriginDataDeleter> weak_factory_;
   DISALLOW_COPY_AND_ASSIGN(OriginDataDeleter);
 };
 
 class QuotaManager::HostDataDeleter : public QuotaTask {
  public:
   HostDataDeleter(QuotaManager* manager,
                   const std::string& host,
                   StorageType type,
+                  int quota_client_mask,
                   const StatusCallback& callback)
       : QuotaTask(manager),
         host_(host),
         type_(type),
+        quota_client_mask_(quota_client_mask),
         error_count_(0),
         remaining_clients_(-1),
         remaining_deleters_(-1),
         callback_(callback),
         weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {}
 
  protected:
   virtual void Run() OVERRIDE {
     error_count_ = 0;
     remaining_clients_ = manager()->clients_.size();
@@ skipping 33 matching lines @@
     }
   }
 
   void ScheduleOriginsDeletion() {
     remaining_deleters_ = origins_.size();
     for (std::set<GURL>::const_iterator p = origins_.begin();
          p != origins_.end();
          ++p) {
       OriginDataDeleter* deleter =
           new OriginDataDeleter(
-              manager(), *p, type_,
+              manager(), *p, type_, quota_client_mask_,
               base::Bind(&HostDataDeleter::DidDeleteOriginData,
                          weak_factory_.GetWeakPtr()));
       deleter->Start();
     }
   }
 
   void DidDeleteOriginData(QuotaStatusCode status) {
     DCHECK_GT(remaining_deleters_, 0);
 
     if (status != kQuotaStatusOk)
       ++error_count_;
 
     if (--remaining_deleters_ == 0)
       CallCompleted();
   }
 
   QuotaManager* manager() const {
     return static_cast<QuotaManager*>(observer());
   }
 
   std::string host_;
   StorageType type_;
+  int quota_client_mask_;
   std::set<GURL> origins_;
   int error_count_;
   int remaining_clients_;
   int remaining_deleters_;
   StatusCallback callback_;
 
   base::WeakPtrFactory<HostDataDeleter> weak_factory_;
   DISALLOW_COPY_AND_ASSIGN(HostDataDeleter);
 };
 
@@ skipping 686 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, const StatusCallback& callback) {
+    const GURL& origin, StorageType type, int quota_client_mask,
+    const StatusCallback& callback) {
   LazyInitialize();
 
-  if (origin.is_empty() || clients_.empty()) {
+  if (origin.is_empty() || clients_.empty() ||
+      quota_client_mask == QuotaClient::kUnknown) {

[kinuko, 2012/01/22 18:35:31]

Not sure this is really meaningful for a bitmask?

[Mike West, 2012/01/22 20:54:38]

Actually, this doesn't make any sense at all. I added it in, thinking that
deleting _only_ kUnknown would be a no-op, but there's no reason that should be
the case. Dropping the check entirely. :)

     callback.Run(kQuotaStatusOk);
     return;
   }
 
   OriginDataDeleter* deleter =
-      new OriginDataDeleter(this, origin, type, callback);
+      new OriginDataDeleter(this, origin, type, quota_client_mask, callback);
   deleter->Start();
 }
 
 void QuotaManager::DeleteHostData(const std::string& host,
                                   StorageType type,
+                                  int quota_client_mask,
                                   const StatusCallback& callback) {
 
   LazyInitialize();
 
   if (host.empty() || clients_.empty()) {
     callback.Run(kQuotaStatusOk);
     return;
   }
 
   HostDataDeleter* deleter =
-      new HostDataDeleter(this, host, type, callback);
+      new HostDataDeleter(this, host, 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 168 matching lines @@
     const GURL& origin,
     StorageType type,
     const 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 = callback;
 
-  DeleteOriginData(origin, type,
+

[kinuko, 2012/01/22 18:35:31]

nit: extra empty line

[Mike West, 2012/01/22 20:54:38]

Done.

+  DeleteOriginData(origin, type, QuotaClient::kAllClientsMask,
       base::Bind(&QuotaManager::DidOriginDataEvicted,
                  weak_factory_.GetWeakPtr()));
 }
 
 void QuotaManager::GetUsageAndQuotaForEviction(
     const GetUsageAndQuotaForEvictionCallback& callback) {
   DCHECK(io_thread_->BelongsToCurrentThread());
   GetUsageAndQuotaInternal(
       GURL(), kStorageTypeTemporary, true /* global */, callback);
 }
@@ skipping 204 matching lines @@
 
 QuotaManagerProxy::QuotaManagerProxy(
     QuotaManager* manager, base::MessageLoopProxy* io_thread)
     : manager_(manager), io_thread_(io_thread) {
 }
 
 QuotaManagerProxy::~QuotaManagerProxy() {
 }
 
 }  // namespace quota