Use base::Callback in Quota related code.

webkit/quota/quota_temporary_storage_evictor.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_temporary_storage_evictor.h"
 
+#include <algorithm>
+
+#include "base/bind.h"
 #include "base/metrics/histogram.h"
 #include "googleurl/src/gurl.h"
 #include "webkit/quota/quota_manager.h"
 
 #define UMA_HISTOGRAM_MBYTES(name, sample)          \
   UMA_HISTOGRAM_CUSTOM_COUNTS(                      \
       (name), static_cast<int>((sample) / kMBytes), \
       1, 10 * 1024 * 1024 /* 10TB */, 100)
 
 #define UMA_HISTOGRAM_MINUTES(name, sample) \
@@ skipping 17 matching lines @@
   base::TimeDelta::FromMilliseconds(60 * 60 * 1000);  // 1 hour
 
 QuotaTemporaryStorageEvictor::QuotaTemporaryStorageEvictor(
     QuotaEvictionHandler* quota_eviction_handler,
     int64 interval_ms)
     : min_available_disk_space_to_start_eviction_(
           kDefaultMinAvailableDiskSpaceToStartEviction),
       quota_eviction_handler_(quota_eviction_handler),
       interval_ms_(interval_ms),
       repeated_eviction_(true),
-      callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
+      weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   DCHECK(quota_eviction_handler);
 }
 
 QuotaTemporaryStorageEvictor::~QuotaTemporaryStorageEvictor() {
 }
 
 void QuotaTemporaryStorageEvictor::GetStatistics(
     std::map<std::string, int64>* statistics) {
   DCHECK(statistics);
 
@@ skipping 81 matching lines @@
   if (eviction_timer_.IsRunning())
     return;
   eviction_timer_.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(delay_ms),
                         this, &QuotaTemporaryStorageEvictor::ConsiderEviction);
 }
 
 void QuotaTemporaryStorageEvictor::ConsiderEviction() {
   OnEvictionRoundStarted();
 
   // Get usage and disk space, then continue.
-  quota_eviction_handler_->GetUsageAndQuotaForEviction(callback_factory_.
-      NewCallback(
-          &QuotaTemporaryStorageEvictor::OnGotUsageAndQuotaForEviction));
+  quota_eviction_handler_->GetUsageAndQuotaForEviction(
+      base::Bind(&QuotaTemporaryStorageEvictor::OnGotUsageAndQuotaForEviction,
+                 weak_factory_.GetWeakPtr()));
 }
 
 void QuotaTemporaryStorageEvictor::OnGotUsageAndQuotaForEviction(
     QuotaStatusCode status,
     int64 usage,
     int64 unlimited_usage,
     int64 quota,
     int64 available_disk_space) {
   DCHECK(CalledOnValidThread());
   DCHECK_GE(usage, unlimited_usage);  // unlimited_usage is a subset of usage
@@ skipping 18 matching lines @@
     round_statistics_.is_initialized = true;
   }
   round_statistics_.usage_on_end_of_round = usage;
 
   int64 amount_to_evict = std::max(usage_overage, diskspace_shortage);
   if (status == kQuotaStatusOk && amount_to_evict > 0) {
     // Space is getting tight. Get the least recently used origin and continue.
     // TODO(michaeln): if the reason for eviction is low physical disk space,
     // make 'unlimited' origins subject to eviction too.
     quota_eviction_handler_->GetLRUOrigin(kStorageTypeTemporary,
-        callback_factory_.NewCallback(
-            &QuotaTemporaryStorageEvictor::OnGotLRUOrigin));
+        base::Bind(&QuotaTemporaryStorageEvictor::OnGotLRUOrigin,
+                   weak_factory_.GetWeakPtr()));
   } else {
     if (repeated_eviction_) {
       // No action required, sleep for a while and check again later.
       if (statistics_.num_errors_on_getting_usage_and_quota <
           kThresholdOfErrorsToStopEviction) {
         StartEvictionTimerWithDelay(interval_ms_);
       } else {
         // TODO(dmikurube): Try restarting eviction after a while.
         LOG(WARNING) << "Stopped eviction of temporary storage due to errors "
                         "in GetUsageAndQuotaForEviction.";
       }
     }
     OnEvictionRoundFinished();
   }
 
   // TODO(dmikurube): Add error handling for the case status != kQuotaStatusOk.
 }
 
 void QuotaTemporaryStorageEvictor::OnGotLRUOrigin(const GURL& origin) {
   DCHECK(CalledOnValidThread());
 
   if (origin.is_empty()) {
     if (repeated_eviction_)
       StartEvictionTimerWithDelay(interval_ms_);
     OnEvictionRoundFinished();
     return;
   }
 
   quota_eviction_handler_->EvictOriginData(origin, kStorageTypeTemporary,
-      callback_factory_.NewCallback(
-          &QuotaTemporaryStorageEvictor::OnEvictionComplete));
+      base::Bind(
+          &QuotaTemporaryStorageEvictor::OnEvictionComplete,
+          weak_factory_.GetWeakPtr()));
 }
 
 void QuotaTemporaryStorageEvictor::OnEvictionComplete(
     QuotaStatusCode status) {
   DCHECK(CalledOnValidThread());
 
   // Just calling ConsiderEviction() or StartEvictionTimerWithDelay() here is
   // ok.  No need to deal with the case that all of the Delete operations fail
   // for a certain origin.  It doesn't result in trying to evict the same
   // origin permanently.  The evictor skips origins which had deletion errors
   // a few times.
 
   if (status == kQuotaStatusOk) {
     ++statistics_.num_evicted_origins;
     ++round_statistics_.num_evicted_origins_in_round;
     // We many need to get rid of more space so reconsider immediately.
     ConsiderEviction();
   } else {
     ++statistics_.num_errors_on_evicting_origin;
     if (repeated_eviction_) {
       // Sleep for a while and retry again until we see too many errors.
       StartEvictionTimerWithDelay(interval_ms_);
     }
     OnEvictionRoundFinished();
   }
 }
 
 }  // namespace quota