Quota UsageTracker ASAN fix

webkit/quota/usage_tracker.cc

 // 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/usage_tracker.h"
 
 #include <algorithm>
 #include <deque>
 #include <set>
 #include <string>
@@ skipping 18 matching lines @@
  public:
   GatherUsageTaskBase(
       UsageTracker* tracker,
       QuotaClient* client)
       : QuotaTask(tracker),
         client_(client),
         tracker_(tracker),
         weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
     DCHECK(tracker_);
     DCHECK(client_);
-    client_tracker_ = tracker_->GetClientTracker(client_->id());
-    DCHECK(client_tracker_);
+    client_tracker_ = base::AsWeakPtr(
+        tracker_->GetClientTracker(client_->id()));
+    DCHECK(client_tracker_.get());
   }
   virtual ~GatherUsageTaskBase() {}
 
   // Get total usage for the given |origins|.
   void GetUsageForOrigins(const std::set<GURL>& origins, StorageType type) {
     DCHECK(original_task_runner()->BelongsToCurrentThread());
+    if (!client_tracker()) {
+      DeleteSoon();
+      return;
+    }
     // We do not get usage for origins for which we have valid usage cache.
     std::vector<GURL> origins_to_gather;
     std::set<GURL> cached_origins;
     client_tracker()->GetCachedOrigins(&cached_origins);
     std::set<GURL> already_added;
     for (std::set<GURL>::const_iterator iter = origins.begin();
          iter != origins.end(); ++iter) {
       if (cached_origins.find(*iter) == cached_origins.end() &&
           already_added.insert(*iter).second) {
         origins_to_gather.push_back(*iter);
@@ skipping 23 matching lines @@
           base::Bind(&GatherUsageTaskBase::DidGetUsage,
                      weak_factory_.GetWeakPtr()));
   }
 
  protected:
   virtual void Aborted() OVERRIDE {
     DeleteSoon();
   }
 
   UsageTracker* tracker() const { return tracker_; }
-  ClientUsageTracker* client_tracker() const { return client_tracker_; }
+  ClientUsageTracker* client_tracker() const { return client_tracker_.get(); }
 
  private:
   void DidGetUsage(int64 usage) {
+    if (!client_tracker()) {
+      DeleteSoon();
+      return;
+    }
+
     DCHECK(original_task_runner()->BelongsToCurrentThread());
     DCHECK(!pending_origins_.empty());
-    DCHECK(client_tracker_);
 
     // Defend against confusing inputs from QuotaClients.
     DCHECK_GE(usage, 0);
     if (usage < 0)
       usage = 0;
 
     // This code assumes DidGetUsage callbacks are called in the same
     // order as we dispatched GetOriginUsage calls.
     const GURL& origin = pending_origins_.front();
     std::string host = net::GetHostOrSpecFromURL(origin);
     client_tracker_->AddCachedOrigin(origin, usage);
 
     pending_origins_.pop_front();
     if (pending_origins_.empty() ||
         host != net::GetHostOrSpecFromURL(pending_origins_.front())) {
       client_tracker_->AddCachedHost(host);
     }
 
     if (pending_origins_.empty()) {
       // We're done.
       CallCompleted();
       DeleteSoon();
     }
   }
 
   QuotaClient* client_;
   UsageTracker* tracker_;
-  ClientUsageTracker* client_tracker_;
+  base::WeakPtr<ClientUsageTracker> client_tracker_;
   std::deque<GURL> pending_origins_;
   std::map<GURL, int64> origin_usage_map_;
   base::WeakPtrFactory<GatherUsageTaskBase> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(GatherUsageTaskBase);
 };
 
 // A task class for getting the total amount of data used for a given storage
 // type.  This class is self-destructed.
 class ClientUsageTracker::GatherGlobalUsageTask
@@ skipping 375 matching lines @@
 void ClientUsageTracker::NoopHostUsageCallback(
     const std::string& host,  StorageType type, int64 usage) {
 }
 
 bool ClientUsageTracker::IsStorageUnlimited(const GURL& origin) const {
   return special_storage_policy_.get() &&
          special_storage_policy_->IsStorageUnlimited(origin);
 }
 
 }  // namespace quota