QuotaManager::GetUsageAndQuota should not hung when the returned usage is negative

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 102 matching lines @@
       QuotaManager* manager,
       const std::string& host,
       StorageType type)
       : QuotaTask(manager),
         host_(host),
         type_(type),
         quota_(-1),
         global_usage_(-1),
         host_usage_(-1),
         quota_status_(kQuotaStatusUnknown),
+        waiting_callbacks_(1),
         callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {}
 
   virtual ~UsageAndQuotaDispatcherTask() {
     STLDeleteContainerPointers(callbacks_.begin(), callbacks_.end());
   }
 
-  virtual bool IsCompleted() const = 0;
+  // Subclasses must implement them.
+  virtual void RunBody() = 0;
+  virtual void DispatchCallback(GetUsageAndQuotaCallback* callback) = 0;
 
-  virtual void DispatchCallback(GetUsageAndQuotaCallback* callback) = 0;
+  virtual void Run() OVERRIDE {
+    RunBody();
+    // We initialize waiting_callbacks to 1 so that we won't run
+    // the completion callback until here even some of the callbacks
+    // are dispatched synchronously.
+    CheckCompleted();
+  }
 
   virtual void Aborted() OVERRIDE {
     for (CallbackList::iterator iter = callbacks_.begin();
         iter != callbacks_.end();
         ++iter) {
       (*iter)->Run(kQuotaErrorAbort, 0, 0);
       delete *iter;
     }
     callbacks_.clear();
     DeleteSoon();
   }
 
   virtual void Completed() OVERRIDE {
     DeleteSoon();
   }
+
   QuotaManager* manager() const {
     return static_cast<QuotaManager*>(observer());
   }
 
   std::string host() const { return host_; }
   StorageType type() const { return type_; }
   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_; }
+  QuotaStatusCode quota_status() const { return quota_status_; }
 
-  UsageCallback* NewGlobalUsageCallback() {
+  // Subclasses must call following methods to create a new 'waitable'
+  // callback, which decrements waiting_callbacks when it is called.
+  UsageCallback* NewWaitableGlobalUsageCallback() {
+    ++waiting_callbacks_;
     return callback_factory_.NewCallback(
             &UsageAndQuotaDispatcherTask::DidGetGlobalUsage);
   }
-
-  HostUsageCallback* NewHostUsageCallback() {
+  HostUsageCallback* NewWaitableHostUsageCallback() {
+    ++waiting_callbacks_;
     return callback_factory_.NewCallback(
             &UsageAndQuotaDispatcherTask::DidGetHostUsage);
   }
-
-  QuotaCallback* NewGlobalQuotaCallback() {
+  QuotaCallback* NewWaitableGlobalQuotaCallback() {
+    ++waiting_callbacks_;
     return callback_factory_.NewCallback(
             &UsageAndQuotaDispatcherTask::DidGetGlobalQuota);
   }
-
-  HostQuotaCallback* NewHostQuotaCallback() {
+  HostQuotaCallback* NewWaitableHostQuotaCallback() {
+    ++waiting_callbacks_;
     return callback_factory_.NewCallback(
             &UsageAndQuotaDispatcherTask::DidGetHostQuota);
   }
 
  private:
   void CheckCompleted() {
-    if (IsCompleted()) {
+    if (--waiting_callbacks_ <= 0) {
       // Dispatches callbacks.
       for (CallbackList::iterator iter = callbacks_.begin();
           iter != callbacks_.end();
           ++iter) {
         DispatchCallback(*iter);
         delete *iter;
       }
       callbacks_.clear();
       UsageAndQuotaDispatcherTaskMap& dispatcher_map =
           manager()->usage_and_quota_dispatchers_;
       DCHECK(dispatcher_map.find(std::make_pair(host_, type_)) !=
              dispatcher_map.end());
       dispatcher_map.erase(std::make_pair(host_, type_));
       CallCompleted();
     }
   }
 
   const std::string host_;
   const StorageType type_;
   int64 quota_;
   int64 global_usage_;
   int64 host_usage_;
   QuotaStatusCode quota_status_;
   CallbackList callbacks_;
+  int waiting_callbacks_;
   ScopedCallbackFactory<UsageAndQuotaDispatcherTask> callback_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(UsageAndQuotaDispatcherTask);
 };
 
 class QuotaManager::UsageAndQuotaDispatcherTaskForTemporary
     : public QuotaManager::UsageAndQuotaDispatcherTask {
  public:
   UsageAndQuotaDispatcherTaskForTemporary(
       QuotaManager* manager, const std::string host)
       : UsageAndQuotaDispatcherTask(manager, host, kStorageTypeTemporary) {}
 
  protected:
-  virtual void Run() OVERRIDE {
+  virtual void RunBody() OVERRIDE {
     manager()->temporary_usage_tracker_->GetGlobalUsage(
-        NewGlobalUsageCallback());
+        NewWaitableGlobalUsageCallback());
     manager()->temporary_usage_tracker_->GetHostUsage(
-        host(), NewHostUsageCallback());
-    manager()->GetTemporaryGlobalQuota(NewGlobalQuotaCallback());
-  }
-
-  virtual bool IsCompleted() const OVERRIDE {
-    return (quota() >= 0 && global_usage() >= 0 && host_usage() >= 0);
+        host(), NewWaitableHostUsageCallback());
+    manager()->GetTemporaryGlobalQuota(NewWaitableGlobalQuotaCallback());
   }
 
   virtual void DispatchCallback(GetUsageAndQuotaCallback* callback) OVERRIDE {
     // TODO(kinuko): For now it returns pessimistic quota.  Change this
     // 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(quota_status(), host_usage(), quota() - other_usage);
   }
 };
 
 class QuotaManager::UsageAndQuotaDispatcherTaskForPersistent
     : public QuotaManager::UsageAndQuotaDispatcherTask {
  public:
   UsageAndQuotaDispatcherTaskForPersistent(
       QuotaManager* manager, const std::string host)
       : UsageAndQuotaDispatcherTask(manager, host, kStorageTypePersistent) {}
 
  protected:
-  virtual void Run() OVERRIDE {
+  virtual void RunBody() OVERRIDE {
     manager()->persistent_usage_tracker_->GetHostUsage(
-        host(), NewHostUsageCallback());
+        host(), NewWaitableHostUsageCallback());
     manager()->GetPersistentHostQuota(
-        host(), NewHostQuotaCallback());
-  }
-
-  virtual bool IsCompleted() const OVERRIDE {
-    return (quota() >= 0 && host_usage() >= 0);
+        host(), NewWaitableHostQuotaCallback());
   }
 
   virtual void DispatchCallback(GetUsageAndQuotaCallback* callback) OVERRIDE {
-    callback->Run(status(), host_usage(), quota());
+    callback->Run(quota_status(), host_usage(), quota());
   }
 };
 
 // static
 QuotaManager::UsageAndQuotaDispatcherTask*
 QuotaManager::UsageAndQuotaDispatcherTask::Create(
     QuotaManager* manager, const std::string& host, StorageType type) {
   switch (type) {
     case kStorageTypeTemporary:
       return new UsageAndQuotaDispatcherTaskForTemporary(
@@ skipping 811 matching lines @@
 
 QuotaManagerProxy::QuotaManagerProxy(
     QuotaManager* manager, base::MessageLoopProxy* io_thread)
     : manager_(manager), io_thread_(io_thread) {
 }
 
 QuotaManagerProxy::~QuotaManagerProxy() {
 }
 
 }  // namespace quota