webkit/quota/quota_manager.cc - Issue 8070001: Use base::Callback in Quota related code.

Unified Diff: webkit/quota/quota_manager.cc

Issue 8070001: Use base::Callback in Quota related code. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src

Patch Set: choke lint Created 9 years, 3 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Index: webkit/quota/quota_manager.cc

diff --git a/webkit/quota/quota_manager.cc b/webkit/quota/quota_manager.cc

index 60d7c323c682683a8c2b5fb6e90c7854c5c33eb2..bd3303a46e5a7141a522d2a9cb70221695a1fbf1 100644

--- a/webkit/quota/quota_manager.cc

+++ b/webkit/quota/quota_manager.cc

@@ -15,7 +15,6 @@

#include "base/memory/ref_counted.h"

#include "base/message_loop_proxy.h"

#include "base/metrics/histogram.h"

-#include "base/stl_util.h"

#include "base/string_number_conversions.h"

#include "base/sys_info.h"

#include "base/time.h"

@@ -30,8 +29,6 @@

(name), static_cast<int>((sample) / kMBytes), \

1, 10 * 1024 * 1024 /* 10TB */, 100)

-using base::ScopedCallbackFactory;

namespace quota {

namespace {

@@ -114,14 +111,14 @@ const base::TimeDelta QuotaManager::kReportHistogramInterval =

// This class is self-destructed.

class QuotaManager::UsageAndQuotaDispatcherTask : public QuotaTask {

public:

- typedef std::deque<GetUsageAndQuotaCallback*> CallbackList;

+ typedef std::deque<GetUsageAndQuotaCallback> CallbackList;

static UsageAndQuotaDispatcherTask* Create(

QuotaManager* manager, const std::string& host, StorageType type);

// Returns true if it is the first call for this task; which means

// the caller needs to call Start().

- bool AddCallback(GetUsageAndQuotaCallback* callback, bool unlimited) {

+ bool AddCallback(GetUsageAndQuotaCallback callback, bool unlimited) {

if (unlimited)

unlimited_callbacks_.push_back(callback);

else

@@ -181,13 +178,9 @@ class QuotaManager::UsageAndQuotaDispatcherTask : public QuotaTask {

host_usage_(-1),

quota_status_(kQuotaStatusUnknown),

waiting_callbacks_(1),

- callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {}

+ weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {}

- virtual ~UsageAndQuotaDispatcherTask() {

- STLDeleteContainerPointers(callbacks_.begin(), callbacks_.end());

- STLDeleteContainerPointers(unlimited_callbacks_.begin(),

- unlimited_callbacks_.end());

- }

+ virtual ~UsageAndQuotaDispatcherTask() {}

// Subclasses must implement them.

virtual void RunBody() = 0;

@@ -216,8 +209,7 @@ class QuotaManager::UsageAndQuotaDispatcherTask : public QuotaTask {

int64 usage, int64 quota) {

for (CallbackList::iterator iter = callbacks->begin();

iter != callbacks->end(); ++iter) {

- (*iter)->Run(status, usage, quota);

- delete *iter;

+ iter->Run(status, usage, quota);

}

callbacks->clear();

}

@@ -238,25 +230,25 @@ class QuotaManager::UsageAndQuotaDispatcherTask : public QuotaTask {

// Subclasses must call following methods to create a new 'waitable'

// callback, which decrements waiting_callbacks when it is called.

- GlobalUsageCallback* NewWaitableGlobalUsageCallback() {

+ GlobalUsageCallback NewWaitableGlobalUsageCallback() {

++waiting_callbacks_;

- return callback_factory_.NewCallback(

- &UsageAndQuotaDispatcherTask::DidGetGlobalUsage);

+ return base::Bind(&UsageAndQuotaDispatcherTask::DidGetGlobalUsage,

+ weak_factory_.GetWeakPtr());

}

- HostUsageCallback* NewWaitableHostUsageCallback() {

+ HostUsageCallback NewWaitableHostUsageCallback() {

++waiting_callbacks_;

- return callback_factory_.NewCallback(

- &UsageAndQuotaDispatcherTask::DidGetHostUsage);

+ return base::Bind(&UsageAndQuotaDispatcherTask::DidGetHostUsage,

+ weak_factory_.GetWeakPtr());

}

- QuotaCallback* NewWaitableGlobalQuotaCallback() {

+ QuotaCallback NewWaitableGlobalQuotaCallback() {

++waiting_callbacks_;

- return callback_factory_.NewCallback(

- &UsageAndQuotaDispatcherTask::DidGetGlobalQuota);

+ return base::Bind(&UsageAndQuotaDispatcherTask::DidGetGlobalQuota,

+ weak_factory_.GetWeakPtr());

}

- HostQuotaCallback* NewWaitableHostQuotaCallback() {

+ HostQuotaCallback NewWaitableHostQuotaCallback() {

++waiting_callbacks_;

- return callback_factory_.NewCallback(

- &UsageAndQuotaDispatcherTask::DidGetHostQuota);

+ return base::Bind(&UsageAndQuotaDispatcherTask::DidGetHostQuota,

+ weak_factory_.GetWeakPtr());

}

private:

@@ -285,7 +277,7 @@ class QuotaManager::UsageAndQuotaDispatcherTask : public QuotaTask {

CallbackList callbacks_;

CallbackList unlimited_callbacks_;

int waiting_callbacks_;

- ScopedCallbackFactory<UsageAndQuotaDispatcherTask> callback_factory_;

+ base::WeakPtrFactory<UsageAndQuotaDispatcherTask> weak_factory_;

DISALLOW_COPY_AND_ASSIGN(UsageAndQuotaDispatcherTask);

};

@@ -379,14 +371,14 @@ class QuotaManager::OriginDataDeleter : public QuotaTask {

OriginDataDeleter(QuotaManager* manager,

const GURL& origin,

StorageType type,

- StatusCallback* callback)

+ StatusCallback callback)

: QuotaTask(manager),

origin_(origin),

type_(type),

error_count_(0),

remaining_clients_(-1),

callback_(callback),

- callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {}

+ weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {}

protected:

virtual void Run() OVERRIDE {

@@ -394,23 +386,25 @@ class QuotaManager::OriginDataDeleter : public QuotaTask {

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));

+ (*iter)->DeleteOriginData(

+ origin_, type_,

+ base::Bind(&OriginDataDeleter::DidDeleteOriginData,

+ weak_factory_.GetWeakPtr()));

}

virtual void Completed() OVERRIDE {

if (error_count_ == 0) {

manager()->DeleteOriginFromDatabase(origin_, type_);

- callback_->Run(kQuotaStatusOk);

+ callback_.Run(kQuotaStatusOk);

} else {

- callback_->Run(kQuotaErrorInvalidModification);

+ callback_.Run(kQuotaErrorInvalidModification);

}

DeleteSoon();

}

virtual void Aborted() OVERRIDE {

- callback_->Run(kQuotaErrorAbort);

+ callback_.Run(kQuotaErrorAbort);

DeleteSoon();

}

@@ -432,9 +426,9 @@ class QuotaManager::OriginDataDeleter : public QuotaTask {

StorageType type_;

int error_count_;

int remaining_clients_;

- scoped_ptr<StatusCallback> callback_;

+ StatusCallback callback_;

- ScopedCallbackFactory<OriginDataDeleter> callback_factory_;

+ base::WeakPtrFactory<OriginDataDeleter> weak_factory_;

DISALLOW_COPY_AND_ASSIGN(OriginDataDeleter);

};

@@ -526,7 +520,7 @@ class QuotaManager::UpdateTemporaryGlobalQuotaTask

UpdateTemporaryGlobalQuotaTask(

QuotaManager* manager,

int64 new_quota,

- QuotaCallback* callback)

+ QuotaCallback callback)

: DatabaseTaskBase(manager),

new_quota_(new_quota),

callback_(callback) {

@@ -542,8 +536,8 @@ class QuotaManager::UpdateTemporaryGlobalQuotaTask

}

virtual void DatabaseTaskCompleted() OVERRIDE {

- callback_->Run(db_disabled() ? kQuotaErrorInvalidAccess : kQuotaStatusOk,

- kStorageTypeTemporary, new_quota_);

+ callback_.Run(db_disabled() ? kQuotaErrorInvalidAccess : kQuotaStatusOk,

+ kStorageTypeTemporary, new_quota_);

if (!db_disabled()) {

manager()->temporary_global_quota_ = new_quota_;

}

@@ -551,7 +545,7 @@ class QuotaManager::UpdateTemporaryGlobalQuotaTask

private:

int64 new_quota_;

- scoped_ptr<QuotaCallback> callback_;

+ QuotaCallback callback_;

};

class QuotaManager::GetPersistentHostQuotaTask

@@ -560,7 +554,7 @@ class QuotaManager::GetPersistentHostQuotaTask

GetPersistentHostQuotaTask(

QuotaManager* manager,

const std::string& host,

- HostQuotaCallback* callback)

+ HostQuotaCallback callback)

: DatabaseTaskBase(manager),

host_(host),

quota_(-1),

@@ -572,13 +566,13 @@ class QuotaManager::GetPersistentHostQuotaTask

quota_ = 0;

}

virtual void DatabaseTaskCompleted() OVERRIDE {

- callback_->Run(kQuotaStatusOk,

- host_, kStorageTypePersistent, quota_);

+ callback_.Run(kQuotaStatusOk,

+ host_, kStorageTypePersistent, quota_);

}

private:

std::string host_;

int64 quota_;

- scoped_ptr<HostQuotaCallback> callback_;

+ HostQuotaCallback callback_;

};

class QuotaManager::UpdatePersistentHostQuotaTask

@@ -588,7 +582,7 @@ class QuotaManager::UpdatePersistentHostQuotaTask

QuotaManager* manager,

const std::string& host,

int new_quota,

- HostQuotaCallback* callback)

+ HostQuotaCallback callback)

: DatabaseTaskBase(manager),

host_(host),

new_quota_(new_quota),

@@ -604,18 +598,18 @@ class QuotaManager::UpdatePersistentHostQuotaTask

}

virtual void DatabaseTaskCompleted() OVERRIDE {

- callback_->Run(db_disabled() ? kQuotaErrorInvalidAccess : kQuotaStatusOk,

- host_, kStorageTypePersistent, new_quota_);

+ callback_.Run(db_disabled() ? kQuotaErrorInvalidAccess : kQuotaStatusOk,

+ host_, kStorageTypePersistent, new_quota_);

}

virtual void Aborted() OVERRIDE {

- callback_.reset();

+ callback_.Reset();

}

private:

std::string host_;

int64 new_quota_;

- scoped_ptr<HostQuotaCallback> callback_;

+ HostQuotaCallback callback_;

};

class QuotaManager::GetLRUOriginTask

@@ -626,7 +620,7 @@ class QuotaManager::GetLRUOriginTask

StorageType type,

const std::map<GURL, int>& origins_in_use,

const std::map<GURL, int>& origins_in_error,

- GetLRUOriginCallback *callback)

+ GetLRUOriginCallback callback)

: DatabaseTaskBase(manager),

type_(type),

callback_(callback),

@@ -653,17 +647,17 @@ class QuotaManager::GetLRUOriginTask

}

virtual void DatabaseTaskCompleted() OVERRIDE {

- callback_->Run(url_);

+ callback_.Run(url_);

}

virtual void Aborted() OVERRIDE {

- callback_.reset();

+ callback_.Reset();

}

private:

StorageType type_;

std::set<GURL> exceptions_;

- scoped_ptr<GetLRUOriginCallback> callback_;

+ GetLRUOriginCallback callback_;

scoped_refptr<SpecialStoragePolicy> special_storage_policy_;

GURL url_;

};

@@ -733,7 +727,7 @@ class QuotaManager::AvailableSpaceQueryTask : public QuotaThreadTask {

QuotaManager* manager,

scoped_refptr<base::MessageLoopProxy> db_message_loop,

const FilePath& profile_path,

- AvailableSpaceCallback* callback)

+ AvailableSpaceCallback callback)

: QuotaThreadTask(manager, db_message_loop),

profile_path_(profile_path),

space_(-1),

@@ -746,17 +740,17 @@ class QuotaManager::AvailableSpaceQueryTask : public QuotaThreadTask {

}

virtual void Aborted() OVERRIDE {

- callback_->Run(kQuotaErrorAbort, -1);

+ callback_.Run(kQuotaErrorAbort, -1);

}

virtual void Completed() OVERRIDE {

- callback_->Run(kQuotaStatusOk, space_);

+ callback_.Run(kQuotaStatusOk, space_);

}

private:

FilePath profile_path_;

int64 space_;

- scoped_ptr<AvailableSpaceCallback> callback_;

+ AvailableSpaceCallback callback_;

};

class QuotaManager::UpdateAccessTimeTask

@@ -821,7 +815,7 @@ class QuotaManager::GetModifiedSinceTask

QuotaManager* manager,

StorageType type,

base::Time modified_since,

- GetOriginsCallback* callback)

+ GetOriginsCallback callback)

: DatabaseTaskBase(manager),

type_(type),

modified_since_(modified_since),

@@ -836,18 +830,18 @@ class QuotaManager::GetModifiedSinceTask

}

virtual void DatabaseTaskCompleted() OVERRIDE {

- callback_->Run(origins_, type_);

+ callback_.Run(origins_, type_);

}

virtual void Aborted() OVERRIDE {

- callback_->Run(std::set<GURL>(), type_);

+ callback_.Run(std::set<GURL>(), type_);

}

private:

StorageType type_;

base::Time modified_since_;

std::set<GURL> origins_;

- scoped_ptr<GetOriginsCallback> callback_;

+ GetOriginsCallback callback_;

};

class QuotaManager::DumpQuotaTableTask

@@ -862,7 +856,7 @@ class QuotaManager::DumpQuotaTableTask

public:

DumpQuotaTableTask(

QuotaManager* manager,

- Callback* callback)

+ Callback callback)

: DatabaseTaskBase(manager),

callback_(callback) {

}

@@ -875,11 +869,11 @@ class QuotaManager::DumpQuotaTableTask

}

virtual void Aborted() OVERRIDE {

- callback_->Run(TableEntries());

+ callback_.Run(TableEntries());

}

virtual void DatabaseTaskCompleted() OVERRIDE {

- callback_->Run(entries_);

+ callback_.Run(entries_);

}

private:

@@ -888,7 +882,7 @@ class QuotaManager::DumpQuotaTableTask

return true;

}

- scoped_ptr<Callback> callback_;

+ Callback callback_;

TableEntries entries_;

};

@@ -904,7 +898,7 @@ class QuotaManager::DumpOriginInfoTableTask

public:

DumpOriginInfoTableTask(

QuotaManager* manager,

- Callback* callback)

+ Callback callback)

: DatabaseTaskBase(manager),

callback_(callback) {

}

@@ -917,11 +911,11 @@ class QuotaManager::DumpOriginInfoTableTask

}

virtual void Aborted() OVERRIDE {

- callback_->Run(TableEntries());

+ callback_.Run(TableEntries());

}

virtual void DatabaseTaskCompleted() OVERRIDE {

- callback_->Run(entries_);

+ callback_.Run(entries_);

}

private:

@@ -930,7 +924,7 @@ class QuotaManager::DumpOriginInfoTableTask

return true;

}

- scoped_ptr<Callback> callback_;

+ Callback callback_;

TableEntries entries_;

};

@@ -952,7 +946,7 @@ QuotaManager::QuotaManager(bool is_incognito,

need_initialize_origins_(false),

temporary_global_quota_(-1),

special_storage_policy_(special_storage_policy),

- callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {

+ weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {

}

QuotaManager::~QuotaManager() {

@@ -966,13 +960,12 @@ QuotaManager::~QuotaManager() {

void QuotaManager::GetUsageAndQuota(

const GURL& origin, StorageType type,

- GetUsageAndQuotaCallback* callback_ptr) {

- scoped_ptr<GetUsageAndQuotaCallback> callback(callback_ptr);

+ GetUsageAndQuotaCallback callback) {

LazyInitialize();

if (type == kStorageTypeUnknown) {

// Quota only supports temporary/persistent types.

- callback->Run(kQuotaErrorNotSupported, 0, 0);

+ callback.Run(kQuotaErrorNotSupported, 0, 0);

return;

}

@@ -986,26 +979,24 @@ void QuotaManager::GetUsageAndQuota(

found = usage_and_quota_dispatchers_.insert(

std::make_pair(std::make_pair(host, type), dispatcher)).first;

}

- if (found->second->AddCallback(

- callback.release(), IsStorageUnlimited(origin))) {

+ if (found->second->AddCallback(callback, IsStorageUnlimited(origin))) {

found->second->Start();

}

-void QuotaManager::GetAvailableSpace(AvailableSpaceCallback* callback) {

+void QuotaManager::GetAvailableSpace(AvailableSpaceCallback callback) {

scoped_refptr<AvailableSpaceQueryTask> task(

new AvailableSpaceQueryTask(this, db_thread_, profile_path_, callback));

task->Start();

}

-void QuotaManager::GetTemporaryGlobalQuota(QuotaCallback* callback) {

+void QuotaManager::GetTemporaryGlobalQuota(QuotaCallback callback) {

LazyInitialize();

if (temporary_global_quota_ >= 0) {

// TODO(kinuko): We may want to adjust the quota when the current

// available space in the hard drive is getting tight.

- callback->Run(kQuotaStatusOk,

- kStorageTypeTemporary, temporary_global_quota_);

- delete callback;

+ callback.Run(kQuotaStatusOk,

+ kStorageTypeTemporary, temporary_global_quota_);

return;

}

// They are called upon completion of InitializeTask.

@@ -1013,12 +1004,11 @@ void QuotaManager::GetTemporaryGlobalQuota(QuotaCallback* callback) {

}

void QuotaManager::SetTemporaryGlobalQuota(int64 new_quota,

- QuotaCallback* callback) {

+ QuotaCallback callback) {

LazyInitialize();

if (new_quota < 0) {

- callback->Run(kQuotaErrorInvalidModification,

+ callback.Run(kQuotaErrorInvalidModification,

kStorageTypeTemporary, -1);

- delete callback;

return;

}

@@ -1027,64 +1017,61 @@ void QuotaManager::SetTemporaryGlobalQuota(int64 new_quota,

new UpdateTemporaryGlobalQuotaTask(this, new_quota, callback));

task->Start();

} else {

- callback->Run(kQuotaErrorInvalidAccess,

+ callback.Run(kQuotaErrorInvalidAccess,

kStorageTypeTemporary, -1);

- delete callback;

}

void QuotaManager::GetPersistentHostQuota(const std::string& host,

- HostQuotaCallback* callback_ptr) {

- scoped_ptr<HostQuotaCallback> callback(callback_ptr);

+ HostQuotaCallback callback) {

LazyInitialize();

if (host.empty()) {

// This could happen if we are called on file:///.

// TODO(kinuko) We may want to respect --allow-file-access-from-files

// command line switch.

- callback->Run(kQuotaStatusOk, host, kStorageTypePersistent, 0);

+ callback.Run(kQuotaStatusOk, host, kStorageTypePersistent, 0);

return;

}

scoped_refptr<GetPersistentHostQuotaTask> task(

- new GetPersistentHostQuotaTask(this, host, callback.release()));

+ new GetPersistentHostQuotaTask(this, host, callback));

task->Start();

}

void QuotaManager::SetPersistentHostQuota(const std::string& host,

int64 new_quota,

- HostQuotaCallback* callback_ptr) {

- scoped_ptr<HostQuotaCallback> callback(callback_ptr);

+ HostQuotaCallback callback) {

LazyInitialize();

if (host.empty()) {

// This could happen if we are called on file:///.

- callback->Run(kQuotaErrorNotSupported, host, kStorageTypePersistent, 0);

+ callback.Run(kQuotaErrorNotSupported, host, kStorageTypePersistent, 0);

return;

}

if (new_quota < 0) {

- callback->Run(kQuotaErrorInvalidModification,

- host, kStorageTypePersistent, -1);

+ callback.Run(kQuotaErrorInvalidModification,

+ host, kStorageTypePersistent, -1);

return;

}

if (!db_disabled_) {

scoped_refptr<UpdatePersistentHostQuotaTask> task(

new UpdatePersistentHostQuotaTask(

- this, host, new_quota, callback.release()));

+ this, host, new_quota, callback));

task->Start();

} else {

- callback->Run(kQuotaErrorInvalidAccess,

+ callback.Run(kQuotaErrorInvalidAccess,

host, kStorageTypePersistent, -1);

}

void QuotaManager::GetGlobalUsage(

StorageType type,

- GlobalUsageCallback* callback) {

+ GlobalUsageCallback callback) {

LazyInitialize();

GetUsageTracker(type)->GetGlobalUsage(callback);

}

void QuotaManager::GetHostUsage(const std::string& host, StorageType type,

- HostUsageCallback* callback) {

+ HostUsageCallback callback) {

LazyInitialize();

GetUsageTracker(type)->GetHostUsage(host, callback);

}

@@ -1105,7 +1092,7 @@ void QuotaManager::GetStatistics(

void QuotaManager::GetOriginsModifiedSince(

StorageType type,

base::Time modified_since,

- GetOriginsCallback* callback) {

+ GetOriginsCallback callback) {

LazyInitialize();

make_scoped_refptr(new GetModifiedSinceTask(

this, type, modified_since, callback))->Start();

@@ -1167,12 +1154,11 @@ void QuotaManager::NotifyOriginNoLongerInUse(const GURL& origin) {

}

void QuotaManager::DeleteOriginData(

- const GURL& origin, StorageType type, StatusCallback* callback) {

+ const GURL& origin, StorageType type, StatusCallback callback) {

LazyInitialize();

if (origin.is_empty() || clients_.empty()) {

- callback->Run(kQuotaStatusOk);

- delete callback;

+ callback.Run(kQuotaStatusOk);

return;

}

@@ -1238,7 +1224,7 @@ void QuotaManager::NotifyStorageAccessedInternal(

const GURL& origin, StorageType type,

base::Time accessed_time) {

LazyInitialize();

- if (type == kStorageTypeTemporary && lru_origin_callback_.get()) {

+ if (type == kStorageTypeTemporary && !lru_origin_callback_.is_null()) {

// Record the accessed origins while GetLRUOrigin task is runing

// to filter out them from eviction.

access_notified_origins_.insert(origin);

@@ -1262,12 +1248,12 @@ void QuotaManager::NotifyStorageModifiedInternal(

this, origin, type, modified_time))->Start();

}

-void QuotaManager::DumpQuotaTable(DumpQuotaTableCallback* callback) {

+void QuotaManager::DumpQuotaTable(DumpQuotaTableCallback callback) {

make_scoped_refptr(new DumpQuotaTableTask(this, callback))->Start();

}

void QuotaManager::DumpOriginInfoTable(

- DumpOriginInfoTableCallback* callback) {

+ DumpOriginInfoTableCallback callback) {

make_scoped_refptr(new DumpOriginInfoTableTask(this, callback))->Start();

}

@@ -1284,20 +1270,21 @@ void QuotaManager::DeleteOriginFromDatabase(

void QuotaManager::GetLRUOrigin(

StorageType type,

- GetLRUOriginCallback* callback) {

+ GetLRUOriginCallback callback) {

LazyInitialize();

// This must not be called while there's an in-flight task.

- DCHECK(!lru_origin_callback_.get());

- lru_origin_callback_.reset(callback);

+ DCHECK(lru_origin_callback_.is_null());

+ lru_origin_callback_ = callback;

if (db_disabled_) {

- lru_origin_callback_->Run(GURL());

- lru_origin_callback_.reset();

+ lru_origin_callback_.Run(GURL());

+ lru_origin_callback_.Reset();

return;

}

scoped_refptr<GetLRUOriginTask> task(new GetLRUOriginTask(

this, type, origins_in_use_,

- origins_in_error_, callback_factory_.NewCallback(

- &QuotaManager::DidGetDatabaseLRUOrigin)));

+ origins_in_error_,

+ base::Bind(&QuotaManager::DidGetDatabaseLRUOrigin,

+ weak_factory_.GetWeakPtr())));

task->Start();

}

@@ -1312,33 +1299,34 @@ void QuotaManager::DidOriginDataEvicted(

if (status != kQuotaStatusOk)

origins_in_error_[eviction_context_.evicted_origin]++;

- eviction_context_.evict_origin_data_callback->Run(status);

- eviction_context_.evict_origin_data_callback.reset();

+ eviction_context_.evict_origin_data_callback.Run(status);

+ eviction_context_.evict_origin_data_callback.Reset();

}

void QuotaManager::EvictOriginData(

const GURL& origin,

StorageType type,

- EvictOriginDataCallback* callback) {

+ 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);

+ eviction_context_.evict_origin_data_callback = callback;

- DeleteOriginData(origin, type, callback_factory_.NewCallback(

- &QuotaManager::DidOriginDataEvicted));

+ DeleteOriginData(origin, type,

+ base::Bind(&QuotaManager::DidOriginDataEvicted,

+ weak_factory_.GetWeakPtr()));

}

void QuotaManager::DidGetAvailableSpaceForEviction(

QuotaStatusCode status,

int64 available_space) {

- eviction_context_.get_usage_and_quota_callback->Run(status,

+ 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();

+ eviction_context_.get_usage_and_quota_callback.Reset();

}

void QuotaManager::DidGetGlobalQuotaForEviction(

@@ -1347,15 +1335,16 @@ void QuotaManager::DidGetGlobalQuotaForEviction(

int64 quota) {

DCHECK_EQ(type, kStorageTypeTemporary);

if (status != kQuotaStatusOk) {

- eviction_context_.get_usage_and_quota_callback->Run(

+ eviction_context_.get_usage_and_quota_callback.Run(

status, 0, 0, 0, 0);

- eviction_context_.get_usage_and_quota_callback.reset();

+ eviction_context_.get_usage_and_quota_callback.Reset();

return;

}

eviction_context_.quota = quota;

- GetAvailableSpace(callback_factory_.

- NewCallback(&QuotaManager::DidGetAvailableSpaceForEviction));

+ GetAvailableSpace(

+ base::Bind(&QuotaManager::DidGetAvailableSpaceForEviction,

+ weak_factory_.GetWeakPtr()));

}

void QuotaManager::DidGetGlobalUsageForEviction(

@@ -1364,19 +1353,21 @@ void QuotaManager::DidGetGlobalUsageForEviction(

DCHECK_GE(usage, unlimited_usage);

eviction_context_.usage = usage;

eviction_context_.unlimited_usage = unlimited_usage;

- GetTemporaryGlobalQuota(callback_factory_.

- NewCallback(&QuotaManager::DidGetGlobalQuotaForEviction));

+ GetTemporaryGlobalQuota(

+ base::Bind(&QuotaManager::DidGetGlobalQuotaForEviction,

+ weak_factory_.GetWeakPtr()));

}

void QuotaManager::GetUsageAndQuotaForEviction(

- GetUsageAndQuotaForEvictionCallback* callback) {

+ GetUsageAndQuotaForEvictionCallback callback) {

DCHECK(io_thread_->BelongsToCurrentThread());

- DCHECK(!eviction_context_.get_usage_and_quota_callback.get());

+ DCHECK(eviction_context_.get_usage_and_quota_callback.is_null());

- eviction_context_.get_usage_and_quota_callback.reset(callback);

+ eviction_context_.get_usage_and_quota_callback = callback;

// TODO(dmikurube): Make kStorageTypeTemporary an argument.

- GetGlobalUsage(kStorageTypeTemporary, callback_factory_.

- NewCallback(&QuotaManager::DidGetGlobalUsageForEviction));

+ GetGlobalUsage(kStorageTypeTemporary,

+ base::Bind(&QuotaManager::DidGetGlobalUsageForEviction,

+ weak_factory_.GetWeakPtr()));

}

void QuotaManager::StartEviction() {

@@ -1388,11 +1379,13 @@ void QuotaManager::StartEviction() {

void QuotaManager::ReportHistogram() {

GetGlobalUsage(kStorageTypeTemporary,

- callback_factory_.NewCallback(

- &QuotaManager::DidGetTemporaryGlobalUsageForHistogram));

+ base::Bind(

+ &QuotaManager::DidGetTemporaryGlobalUsageForHistogram,

+ weak_factory_.GetWeakPtr()));

GetGlobalUsage(kStorageTypePersistent,

- callback_factory_.NewCallback(

- &QuotaManager::DidGetPersistentGlobalUsageForHistogram));

+ base::Bind(

+ &QuotaManager::DidGetPersistentGlobalUsageForHistogram,

+ weak_factory_.GetWeakPtr()));

}

void QuotaManager::DidGetTemporaryGlobalUsageForHistogram(

@@ -1460,8 +1453,9 @@ void QuotaManager::DidInitializeTemporaryGlobalQuota(int64 quota) {

// of origins that have data in temporary storage to register them

// in the database. (We'll need the global temporary usage anyway

// for eviction later.)

- temporary_usage_tracker_->GetGlobalUsage(callback_factory_.NewCallback(

- &QuotaManager::DidRunInitialGetTemporaryGlobalUsage));

+ temporary_usage_tracker_->GetGlobalUsage(

+ base::Bind(&QuotaManager::DidRunInitialGetTemporaryGlobalUsage,

+ weak_factory_.GetWeakPtr()));

}

void QuotaManager::DidRunInitialGetTemporaryGlobalUsage(

@@ -1480,11 +1474,11 @@ void QuotaManager::DidGetDatabaseLRUOrigin(const GURL& origin) {

// and has not been accessed since we posted the task.

if (origins_in_use_.find(origin) != origins_in_use_.end() ||

access_notified_origins_.find(origin) != access_notified_origins_.end())

- lru_origin_callback_->Run(GURL());

+ lru_origin_callback_.Run(GURL());

else

- lru_origin_callback_->Run(origin);

+ lru_origin_callback_.Run(origin);

access_notified_origins_.clear();

- lru_origin_callback_.reset();

+ lru_origin_callback_.Reset();

}

void QuotaManager::DeleteOnCorrectThread() const {

« webkit/quota/quota_manager.h ('K') | « webkit/quota/quota_manager.h ('k') | webkit/quota/quota_manager_unittest.cc » ('j') | webkit/quota/quota_types.h » ('J')