chromium/src
0
Fork 0
Code Activity

Use base::Callback in Quota related code.

Browse Source 
BUG=None
TEST='Compilation should finished successfull and all quota related tests should be passed.'

Review URL: http://codereview.chromium.org/8070001

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@106060 0039d316-1c4b-4281-b951-d872f2087c98
This commit is contained in:
tzik@chromium.org
2011-10-18 14:11:03 +00:00
parent 58ae297434
commit 4d99be5a3d
49 changed files with 757 additions and 734 deletions

20
chrome/browser/browsing_data_quota_helper_impl.cc

@ -7,6 +7,7 @@
#include <map>
#include <set>
#include "base/bind.h"
#include "base/logging.h"
#include "chrome/browser/profiles/profile.h"
#include "webkit/quota/quota_manager.h"
@ -46,8 +47,9 @@ void BrowsingDataQuotaHelperImpl::RevokeHostQuota(const std::string& host) {
}
quota_manager_->SetPersistentHostQuota(
host, 0, callback_factory_.NewCallback(
&BrowsingDataQuotaHelperImpl::DidRevokeHostQuota));
host, 0,
base::Bind(&BrowsingDataQuotaHelperImpl::DidRevokeHostQuota,
weak_factory_.GetWeakPtr()));
}
BrowsingDataQuotaHelperImpl::BrowsingDataQuotaHelperImpl(
@ -59,7 +61,7 @@ BrowsingDataQuotaHelperImpl::BrowsingDataQuotaHelperImpl(
is_fetching_(false),
ui_thread_(ui_thread),
io_thread_(io_thread),
callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
DCHECK(quota_manager);
}
@ -78,8 +80,8 @@ void BrowsingDataQuotaHelperImpl::FetchQuotaInfo() {
quota_manager_->GetOriginsModifiedSince(
quota::kStorageTypeTemporary,
base::Time(),
callback_factory_.NewCallback(
&BrowsingDataQuotaHelperImpl::GotOrigins));
base::Bind(&BrowsingDataQuotaHelperImpl::GotOrigins,
weak_factory_.GetWeakPtr()));
}
void BrowsingDataQuotaHelperImpl::GotOrigins(
@ -96,8 +98,8 @@ void BrowsingDataQuotaHelperImpl::GotOrigins(
quota_manager_->GetOriginsModifiedSince(
quota::kStorageTypePersistent,
base::Time(),
callback_factory_.NewCallback(
&BrowsingDataQuotaHelperImpl::GotOrigins));
base::Bind(&BrowsingDataQuotaHelperImpl::GotOrigins,
weak_factory_.GetWeakPtr()));
} else {
// type == quota::kStorageTypePersistent
ProcessPendingHosts();
@ -122,8 +124,8 @@ void BrowsingDataQuotaHelperImpl::GetHostUsage(const std::string& host,
DCHECK(quota_manager_.get());
quota_manager_->GetHostUsage(
host, type,
callback_factory_.NewCallback(
&BrowsingDataQuotaHelperImpl::GotHostUsage));
base::Bind(&BrowsingDataQuotaHelperImpl::GotHostUsage,
weak_factory_.GetWeakPtr()));
}
void BrowsingDataQuotaHelperImpl::GotHostUsage(const std::string& host,

2
chrome/browser/browsing_data_quota_helper_impl.h

@ -69,7 +69,7 @@ class BrowsingDataQuotaHelperImpl : public BrowsingDataQuotaHelper {
scoped_refptr<base::MessageLoopProxy> ui_thread_;
scoped_refptr<base::MessageLoopProxy> io_thread_;
base::ScopedCallbackFactory<BrowsingDataQuotaHelperImpl> callback_factory_;
base::WeakPtrFactory<BrowsingDataQuotaHelperImpl> weak_factory_;
friend class BrowsingDataQuotaHelper;
friend class BrowsingDataQuotaHelperTest;

13
chrome/browser/browsing_data_quota_helper_unittest.cc

@ -4,6 +4,7 @@
#include "testing/gtest/include/gtest/gtest.h"
#include "base/bind.h"
#include "base/memory/scoped_callback_factory.h"
#include "base/message_loop_proxy.h"
#include "base/scoped_temp_dir.h"
@ -22,6 +23,7 @@ class BrowsingDataQuotaHelperTest : public testing::Test {
io_thread_(BrowserThread::IO, &message_loop_),
fetching_completed_(true),
quota_(-1),
weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {}
virtual ~BrowsingDataQuotaHelperTest() {}
@ -73,15 +75,17 @@ class BrowsingDataQuotaHelperTest : public testing::Test {
void SetPersistentHostQuota(const std::string& host, int64 quota) {
quota_ = -1;
quota_manager_->SetPersistentHostQuota(
host, quota, callback_factory_.NewCallback(
&BrowsingDataQuotaHelperTest::GotPersistentHostQuota));
host, quota,
base::Bind(&BrowsingDataQuotaHelperTest::GotPersistentHostQuota,
weak_factory_.GetWeakPtr()));
}
void GetPersistentHostQuota(const std::string& host) {
quota_ = -1;
quota_manager_->GetPersistentHostQuota(
host, callback_factory_.NewCallback(
&BrowsingDataQuotaHelperTest::GotPersistentHostQuota));
host,
base::Bind(&BrowsingDataQuotaHelperTest::GotPersistentHostQuota,
weak_factory_.GetWeakPtr()));
}
void GotPersistentHostQuota(quota::QuotaStatusCode status,
@ -119,6 +123,7 @@ class BrowsingDataQuotaHelperTest : public testing::Test {
bool fetching_completed_;
QuotaInfoArray quota_info_;
int64 quota_;
base::WeakPtrFactory<BrowsingDataQuotaHelperTest> weak_factory_;
base::ScopedCallbackFactory<BrowsingDataQuotaHelperTest> callback_factory_;
DISALLOW_COPY_AND_ASSIGN(BrowsingDataQuotaHelperTest);

17
chrome/browser/browsing_data_remover.cc

@ -489,8 +489,9 @@ void BrowsingDataRemover::ClearQuotaManagedDataOnIOThread() {
// timeframe, and deal with the resulting set in
// OnGotPersistentQuotaManagedOrigins.
profile_->GetQuotaManager()->GetOriginsModifiedSince(
quota::kStorageTypePersistent, delete_begin_, NewCallback(this,
&BrowsingDataRemover::OnGotQuotaManagedOrigins));
quota::kStorageTypePersistent, delete_begin_,
base::Bind(&BrowsingDataRemover::OnGotQuotaManagedOrigins,
base::Unretained(this)));
} else {
// Otherwise, we don't need to deal with persistent storage.
--quota_managed_storage_types_to_delete_count_;
@ -499,8 +500,9 @@ void BrowsingDataRemover::ClearQuotaManagedDataOnIOThread() {
// Do the same for temporary quota, regardless, passing the resulting set into
// OnGotTemporaryQuotaManagedOrigins.
profile_->GetQuotaManager()->GetOriginsModifiedSince(
quota::kStorageTypeTemporary, delete_begin_, NewCallback(this,
&BrowsingDataRemover::OnGotQuotaManagedOrigins));
quota::kStorageTypeTemporary, delete_begin_,
base::Bind(&BrowsingDataRemover::OnGotQuotaManagedOrigins,
base::Unretained(this)));
}
void BrowsingDataRemover::OnGotQuotaManagedOrigins(
@ -513,9 +515,10 @@ void BrowsingDataRemover::OnGotQuotaManagedOrigins(
if (special_storage_policy_->IsStorageProtected(origin->GetOrigin()))
continue;
++quota_managed_origins_to_delete_count_;
quota_manager_->DeleteOriginData(origin->GetOrigin(),
type, NewCallback(this,
&BrowsingDataRemover::OnQuotaManagedOriginDeletion));
quota_manager_->DeleteOriginData(
origin->GetOrigin(), type,
base::Bind(&BrowsingDataRemover::OnQuotaManagedOriginDeletion,
base::Unretained(this)));
}
--quota_managed_storage_types_to_delete_count_;

30
chrome/browser/ui/webui/quota_internals_proxy.cc

@ -16,7 +16,7 @@ namespace quota_internals {
QuotaInternalsProxy::QuotaInternalsProxy(QuotaInternalsHandler* handler)
: handler_(handler),
callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
}
QuotaInternalsProxy::~QuotaInternalsProxy() {}
@ -55,30 +55,30 @@ void QuotaInternalsProxy::RequestInfo(
quota_manager_ = quota_manager;
quota_manager_->GetAvailableSpace(
callback_factory_.NewCallback(
&QuotaInternalsProxy::DidGetAvailableSpace));
base::Bind(&QuotaInternalsProxy::DidGetAvailableSpace,
weak_factory_.GetWeakPtr()));
quota_manager_->GetTemporaryGlobalQuota(
callback_factory_.NewCallback(
&QuotaInternalsProxy::DidGetGlobalQuota));
base::Bind(&QuotaInternalsProxy::DidGetGlobalQuota,
weak_factory_.GetWeakPtr()));
quota_manager_->GetGlobalUsage(
quota::kStorageTypeTemporary,
callback_factory_.NewCallback(
&QuotaInternalsProxy::DidGetGlobalUsage));
base::Bind(&QuotaInternalsProxy::DidGetGlobalUsage,
weak_factory_.GetWeakPtr()));
quota_manager_->GetGlobalUsage(
quota::kStorageTypePersistent,
callback_factory_.NewCallback(
&QuotaInternalsProxy::DidGetGlobalUsage));
base::Bind(&QuotaInternalsProxy::DidGetGlobalUsage,
weak_factory_.GetWeakPtr()));
quota_manager_->DumpQuotaTable(
callback_factory_.NewCallback(
&QuotaInternalsProxy::DidDumpQuotaTable));
base::Bind(&QuotaInternalsProxy::DidDumpQuotaTable,
weak_factory_.GetWeakPtr()));
quota_manager_->DumpOriginInfoTable(
callback_factory_.NewCallback(
&QuotaInternalsProxy::DidDumpOriginInfoTable));
base::Bind(&QuotaInternalsProxy::DidDumpOriginInfoTable,
weak_factory_.GetWeakPtr()));
std::map<std::string, std::string> stats;
quota_manager_->GetStatistics(&stats);
@ -180,8 +180,8 @@ void QuotaInternalsProxy::GetHostUsage(const std::string& host,
DCHECK(quota_manager_);
quota_manager_->GetHostUsage(
host, type,
callback_factory_.NewCallback(
&QuotaInternalsProxy::DidGetHostUsage));
base::Bind(&QuotaInternalsProxy::DidGetHostUsage,
weak_factory_.GetWeakPtr()));
}
void QuotaInternalsProxy::RequestPerOriginInfo(quota::StorageType type) {

3
chrome/browser/ui/webui/quota_internals_proxy.h

@ -12,6 +12,7 @@
#include <vector>
#include "base/memory/ref_counted.h"
#include "base/memory/weak_ptr.h"
#include "content/browser/browser_thread.h"
#include "webkit/quota/quota_manager.h"
#include "webkit/quota/quota_types.h"
@ -69,7 +70,7 @@ class QuotaInternalsProxy
QuotaInternalsHandler* handler_;
// Used on IO Thread.
base::ScopedCallbackFactory<QuotaInternalsProxy> callback_factory_;
base::WeakPtrFactory<QuotaInternalsProxy> weak_factory_;
scoped_refptr<quota::QuotaManager> quota_manager_;
std::set<std::pair<std::string, quota::StorageType> >
hosts_visited_, hosts_pending_;

3
content/browser/file_system/file_system_browsertest.cc

@ -2,6 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/bind.h"
#include "base/command_line.h"
#include "base/file_path.h"
#include "base/memory/ref_counted.h"
@ -71,7 +72,7 @@ class FileSystemBrowserTestWithLowQuota : public FileSystemBrowserTest {
return;
}
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
qm->SetTemporaryGlobalOverrideQuota(bytes, NULL);
qm->SetTemporaryGlobalOverrideQuota(bytes, quota::QuotaCallback());
// Don't return until the quota has been set.
scoped_refptr<base::ThreadTestHelper> helper(
new base::ThreadTestHelper(

3
content/browser/in_process_webkit/indexed_db_browsertest.cc

@ -2,6 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/bind.h"
#include "base/command_line.h"
#include "base/file_path.h"
#include "base/file_util.h"
@ -233,7 +234,7 @@ class IndexedDBBrowserTestWithLowQuota : public IndexedDBBrowserTest {
return;
}
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
qm->SetTemporaryGlobalOverrideQuota(bytes, NULL);
qm->SetTemporaryGlobalOverrideQuota(bytes, quota::QuotaCallback());
// Don't return until the quota has been set.
scoped_refptr<base::ThreadTestHelper> helper(
new base::ThreadTestHelper(

60
content/browser/in_process_webkit/indexed_db_context.cc

@ -4,6 +4,7 @@
#include "content/browser/in_process_webkit/indexed_db_context.h"
#include "base/bind.h"
#include "base/command_line.h"
#include "base/file_util.h"
#include "base/logging.h"
@ -87,41 +88,6 @@ const FilePath::CharType IndexedDBContext::kIndexedDBDirectory[] =
const FilePath::CharType IndexedDBContext::kIndexedDBExtension[] =
FILE_PATH_LITERAL(".leveldb");
class IndexedDBContext::IndexedDBGetUsageAndQuotaCallback :
public quota::QuotaManager::GetUsageAndQuotaCallback {
public:
IndexedDBGetUsageAndQuotaCallback(IndexedDBContext* context,
const GURL& origin_url)
: context_(context),
origin_url_(origin_url) {
}
void Run(quota::QuotaStatusCode status, int64 usage, int64 quota) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
DCHECK(status == quota::kQuotaStatusOk || status == quota::kQuotaErrorAbort)
<< "status was " << status;
if (status == quota::kQuotaErrorAbort) {
// We seem to no longer care to wait around for the answer.
return;
}
BrowserThread::PostTask(BrowserThread::WEBKIT, FROM_HERE,
NewRunnableMethod(context_.get(),
&IndexedDBContext::GotUpdatedQuota,
origin_url_,
usage,
quota));
}
virtual void RunWithParams(
const Tuple3<quota::QuotaStatusCode, int64, int64>& params) {
Run(params.a, params.b, params.c);
}
private:
scoped_refptr<IndexedDBContext> context_;
const GURL origin_url_;
};
IndexedDBContext::IndexedDBContext(
WebKitContext* webkit_context,
quota::SpecialStoragePolicy* special_storage_policy,
@ -316,6 +282,25 @@ void IndexedDBContext::QueryDiskAndUpdateQuotaUsage(const GURL& origin_url) {
}
}
void IndexedDBContext::GotUsageAndQuota(const GURL& origin_url,
quota::QuotaStatusCode status,
int64 usage, int64 quota) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
DCHECK(status == quota::kQuotaStatusOk || status == quota::kQuotaErrorAbort)
<< "status was " << status;
if (status == quota::kQuotaErrorAbort) {
// We seem to no longer care to wait around for the answer.
return;
}
BrowserThread::PostTask(
BrowserThread::WEBKIT, FROM_HERE,
NewRunnableMethod(this,
&IndexedDBContext::GotUpdatedQuota,
origin_url,
usage,
quota));
}
void IndexedDBContext::GotUpdatedQuota(const GURL& origin_url, int64 usage,
int64 quota) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
@ -334,12 +319,11 @@ void IndexedDBContext::QueryAvailableQuota(const GURL& origin_url) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
if (!quota_manager_proxy()->quota_manager())
return;
IndexedDBGetUsageAndQuotaCallback* callback =
new IndexedDBGetUsageAndQuotaCallback(this, origin_url);
quota_manager_proxy()->quota_manager()->GetUsageAndQuota(
origin_url,
quota::kStorageTypeTemporary,
callback);
base::Bind(&IndexedDBContext::GotUsageAndQuota,
this, origin_url));
}
std::set<GURL>* IndexedDBContext::GetOriginSet() {

3
content/browser/in_process_webkit/indexed_db_context.h

@ -18,6 +18,7 @@
#include "content/browser/browser_thread.h"
#include "content/common/content_export.h"
#include "googleurl/src/gurl.h"
#include "webkit/quota/quota_types.h"
class GURL;
class FilePath;
@ -94,6 +95,8 @@ class CONTENT_EXPORT IndexedDBContext
int64 ReadUsageFromDisk(const GURL& origin_url) const;
void EnsureDiskUsageCacheInitialized(const GURL& origin_url);
void QueryDiskAndUpdateQuotaUsage(const GURL& origin_url);
void GotUsageAndQuota(const GURL& origin_url, quota::QuotaStatusCode,
int64 usage, int64 quota);
void GotUpdatedQuota(const GURL& origin_url, int64 usage, int64 quota);
void QueryAvailableQuota(const GURL& origin_url);

46
content/browser/in_process_webkit/indexed_db_quota_client.cc

@ -36,7 +36,7 @@ class IndexedDBQuotaClient::DeleteOriginTask : public HelperTask {
DeleteOriginTask(IndexedDBQuotaClient* client,
base::MessageLoopProxy* webkit_thread_message_loop,
const GURL& origin_url,
DeletionCallback* callback)
const DeletionCallback& callback)
: HelperTask(client, webkit_thread_message_loop),
origin_url_(origin_url), callback_(callback) {
}
@ -45,14 +45,14 @@ class IndexedDBQuotaClient::DeleteOriginTask : public HelperTask {
indexed_db_context_->DeleteIndexedDBForOrigin(origin_url_);
}
virtual void Aborted() OVERRIDE {
callback_.reset();
callback_.Reset();
}
virtual void Completed() OVERRIDE {
callback_->Run(quota::kQuotaStatusOk);
callback_.reset();
callback_.Run(quota::kQuotaStatusOk);
callback_.Reset();
}
GURL origin_url_;
scoped_ptr<DeletionCallback> callback_;
DeletionCallback callback_;
};
class IndexedDBQuotaClient::GetOriginUsageTask : public HelperTask {
@ -168,18 +168,17 @@ void IndexedDBQuotaClient::OnQuotaManagerDestroyed() {
void IndexedDBQuotaClient::GetOriginUsage(
const GURL& origin_url,
quota::StorageType type,
GetUsageCallback* callback_ptr) {
DCHECK(callback_ptr);
const GetUsageCallback& callback) {
DCHECK(!callback.is_null());
DCHECK(indexed_db_context_.get());
scoped_ptr<GetUsageCallback> callback(callback_ptr);
// IndexedDB is in the temp namespace for now.
if (type != quota::kStorageTypeTemporary) {
callback->Run(0);
callback.Run(0);
return;
}
if (usage_for_origin_callbacks_.Add(origin_url, callback.release())) {
if (usage_for_origin_callbacks_.Add(origin_url, callback)) {
scoped_refptr<GetOriginUsageTask> task(
new GetOriginUsageTask(this, webkit_thread_message_loop_, origin_url));
task->Start();
@ -188,18 +187,17 @@ void IndexedDBQuotaClient::GetOriginUsage(
void IndexedDBQuotaClient::GetOriginsForType(
quota::StorageType type,
GetOriginsCallback* callback_ptr) {
DCHECK(callback_ptr);
const GetOriginsCallback& callback) {
DCHECK(!callback.is_null());
DCHECK(indexed_db_context_.get());
scoped_ptr<GetOriginsCallback> callback(callback_ptr);
// All databases are in the temp namespace for now.
if (type != quota::kStorageTypeTemporary) {
callback->Run(std::set<GURL>(), type);
callback.Run(std::set<GURL>(), type);
return;
}
if (origins_for_type_callbacks_.Add(callback.release())) {
if (origins_for_type_callbacks_.Add(callback)) {
scoped_refptr<GetAllOriginsTask> task(
new GetAllOriginsTask(this, webkit_thread_message_loop_, type));
task->Start();
@ -209,18 +207,17 @@ void IndexedDBQuotaClient::GetOriginsForType(
void IndexedDBQuotaClient::GetOriginsForHost(
quota::StorageType type,
const std::string& host,
GetOriginsCallback* callback_ptr) {
DCHECK(callback_ptr);
const GetOriginsCallback& callback) {
DCHECK(!callback.is_null());
DCHECK(indexed_db_context_.get());
scoped_ptr<GetOriginsCallback> callback(callback_ptr);
// All databases are in the temp namespace for now.
if (type != quota::kStorageTypeTemporary) {
callback->Run(std::set<GURL>(), type);
callback.Run(std::set<GURL>(), type);
return;
}
if (origins_for_host_callbacks_.Add(host, callback.release())) {
if (origins_for_host_callbacks_.Add(host, callback)) {
scoped_refptr<GetOriginsForHostTask> task(
new GetOriginsForHostTask(
this, webkit_thread_message_loop_, host, type));
@ -228,11 +225,12 @@ void IndexedDBQuotaClient::GetOriginsForHost(
}
}
void IndexedDBQuotaClient::DeleteOriginData(const GURL& origin,
quota::StorageType type,
DeletionCallback* callback) {
void IndexedDBQuotaClient::DeleteOriginData(
const GURL& origin,
quota::StorageType type,
const DeletionCallback& callback) {
if (type != quota::kStorageTypeTemporary) {
callback->Run(quota::kQuotaErrorNotSupported);
callback.Run(quota::kQuotaErrorNotSupported);
return;
}
scoped_refptr<DeleteOriginTask> task(

14
content/browser/in_process_webkit/indexed_db_quota_client.h

@ -33,15 +33,15 @@ class IndexedDBQuotaClient : public quota::QuotaClient,
virtual void OnQuotaManagerDestroyed() OVERRIDE;
virtual void GetOriginUsage(const GURL& origin_url,
quota::StorageType type,
GetUsageCallback* callback) OVERRIDE;
const GetUsageCallback& callback) OVERRIDE;
virtual void GetOriginsForType(quota::StorageType type,
GetOriginsCallback* callback) OVERRIDE;
const GetOriginsCallback& callback) OVERRIDE;
virtual void GetOriginsForHost(quota::StorageType type,
const std::string& host,
GetOriginsCallback* callback) OVERRIDE;
const GetOriginsCallback& callback) OVERRIDE;
virtual void DeleteOriginData(const GURL& origin,
quota::StorageType type,
DeletionCallback* callback) OVERRIDE;
const DeletionCallback& callback) OVERRIDE;
private:
class HelperTask;
class GetOriginUsageTask;
@ -51,17 +51,17 @@ class IndexedDBQuotaClient : public quota::QuotaClient,
class DeleteOriginTask;
typedef quota::CallbackQueueMap1
<GetUsageCallback*,
<GetUsageCallback,
GURL, // origin
int64
> UsageForOriginCallbackMap;
typedef quota::CallbackQueue2
<GetOriginsCallback*,
<GetOriginsCallback,
const std::set<GURL>&,
quota::StorageType
> OriginsForTypeCallbackQueue;
typedef quota::CallbackQueueMap2
<GetOriginsCallback*,
<GetOriginsCallback,
std::string, // host
const std::set<GURL>&,
quota::StorageType

32
content/browser/in_process_webkit/indexed_db_quota_client_unittest.cc

@ -4,6 +4,7 @@
#include <map>
#include "base/bind.h"
#include "base/file_path.h"
#include "base/file_util.h"
#include "base/memory/scoped_callback_factory.h"
@ -35,7 +36,7 @@ class IndexedDBQuotaClientTest : public testing::Test {
kOriginB("http://host:8000"),
kOriginOther("http://other"),
usage_(0),
callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
message_loop_(MessageLoop::TYPE_IO),
webkit_thread_(BrowserThread::WEBKIT, &message_loop_),
io_thread_(BrowserThread::IO, &message_loop_) {
@ -64,9 +65,10 @@ class IndexedDBQuotaClientTest : public testing::Test {
const GURL& origin,
quota::StorageType type) {
usage_ = -1;
client->GetOriginUsage(origin, type,
callback_factory_.NewCallback(
&IndexedDBQuotaClientTest::OnGetOriginUsageComplete));
client->GetOriginUsage(
origin, type,
base::Bind(&IndexedDBQuotaClientTest::OnGetOriginUsageComplete,
weak_factory_.GetWeakPtr()));
MessageLoop::current()->RunAllPending();
EXPECT_GT(usage_, -1);
return usage_;
@ -77,9 +79,10 @@ class IndexedDBQuotaClientTest : public testing::Test {
quota::StorageType type) {
origins_.clear();
type_ = quota::kStorageTypeTemporary;
client->GetOriginsForType(type,
callback_factory_.NewCallback(
&IndexedDBQuotaClientTest::OnGetOriginsComplete));
client->GetOriginsForType(
type,
base::Bind(&IndexedDBQuotaClientTest::OnGetOriginsComplete,
weak_factory_.GetWeakPtr()));
MessageLoop::current()->RunAllPending();
return origins_;
}
@ -90,9 +93,10 @@ class IndexedDBQuotaClientTest : public testing::Test {
const std::string& host) {
origins_.clear();
type_ = quota::kStorageTypeTemporary;
client->GetOriginsForHost(type, host,
callback_factory_.NewCallback(
&IndexedDBQuotaClientTest::OnGetOriginsComplete));
client->GetOriginsForHost(
type, host,
base::Bind(&IndexedDBQuotaClientTest::OnGetOriginsComplete,
weak_factory_.GetWeakPtr()));
MessageLoop::current()->RunAllPending();
return origins_;
}
@ -100,8 +104,10 @@ class IndexedDBQuotaClientTest : public testing::Test {
quota::QuotaStatusCode DeleteOrigin(quota::QuotaClient* client,
const GURL& origin_url) {
delete_status_ = quota::kQuotaStatusUnknown;
client->DeleteOriginData(origin_url, kTemp, callback_factory_.NewCallback(
&IndexedDBQuotaClientTest::OnDeleteOriginComplete));
client->DeleteOriginData(
origin_url, kTemp,
base::Bind(&IndexedDBQuotaClientTest::OnDeleteOriginComplete,
weak_factory_.GetWeakPtr()));
MessageLoop::current()->RunAllPending();
return delete_status_;
}
@ -145,7 +151,7 @@ class IndexedDBQuotaClientTest : public testing::Test {
std::set<GURL> origins_;
quota::StorageType type_;
scoped_refptr<IndexedDBContext> idb_context_;
base::ScopedCallbackFactory<IndexedDBQuotaClientTest> callback_factory_;
base::WeakPtrFactory<IndexedDBQuotaClientTest> weak_factory_;
MessageLoop message_loop_;
BrowserThread webkit_thread_;
BrowserThread io_thread_;

42
content/browser/renderer_host/database_message_filter.cc

@ -6,6 +6,7 @@
#include <string>
#include "base/bind.h"
#include "base/platform_file.h"
#include "base/string_util.h"
#include "base/threading/thread.h"
@ -34,32 +35,6 @@ using webkit_database::VfsBackend;
namespace {
class MyGetUsageAndQuotaCallback
: public QuotaManager::GetUsageAndQuotaCallback {
public:
MyGetUsageAndQuotaCallback(
DatabaseMessageFilter* sender, IPC::Message* reply_msg)
: sender_(sender), reply_msg_(reply_msg) {}
virtual void RunWithParams(
const Tuple3<QuotaStatusCode, int64, int64>& params) {
Run(params.a, params.b, params.c);
}
void Run(QuotaStatusCode status, int64 usage, int64 quota) {
int64 available = 0;
if ((status == quota::kQuotaStatusOk) && (usage < quota))
available = quota - usage;
DatabaseHostMsg_GetSpaceAvailable::WriteReplyParams(
reply_msg_.get(), available);
sender_->Send(reply_msg_.release());
}
private:
scoped_refptr<DatabaseMessageFilter> sender_;
scoped_ptr<IPC::Message> reply_msg_;
};
const int kNumDeleteRetries = 2;
const int kDelayDeleteRetryMs = 100;
@ -293,7 +268,20 @@ void DatabaseMessageFilter::OnDatabaseGetSpaceAvailable(
quota_manager->GetUsageAndQuota(
DatabaseUtil::GetOriginFromIdentifier(origin_identifier),
quota::kStorageTypeTemporary,
new MyGetUsageAndQuotaCallback(this, reply_msg));
base::Bind(&DatabaseMessageFilter::OnDatabaseGetUsageAndQuota,
this, reply_msg));
}
void DatabaseMessageFilter::OnDatabaseGetUsageAndQuota(
IPC::Message* reply_msg,
quota::QuotaStatusCode status,
int64 usage,
int64 quota) {
int64 available = 0;
if ((status == quota::kQuotaStatusOk) && (usage < quota))
available = quota - usage;
DatabaseHostMsg_GetSpaceAvailable::WriteReplyParams(reply_msg, available);
Send(reply_msg);
}
void DatabaseMessageFilter::OnDatabaseOpened(const string16& origin_identifier,

5
content/browser/renderer_host/database_message_filter.h

@ -11,6 +11,7 @@
#include "content/browser/browser_message_filter.h"
#include "webkit/database/database_connections.h"
#include "webkit/database/database_tracker.h"
#include "webkit/quota/quota_types.h"
class DatabaseMessageFilter
: public BrowserMessageFilter,
@ -52,6 +53,10 @@ class DatabaseMessageFilter
// Quota message handler (io thread)
void OnDatabaseGetSpaceAvailable(const string16& origin_identifier,
IPC::Message* reply_msg);
void OnDatabaseGetUsageAndQuota(IPC::Message* reply_msg,
quota::QuotaStatusCode status,
int64 usage,
int64 quota);
// Database tracker message handlers (file thread)
void OnDatabaseOpened(const string16& origin_identifier,

24
content/browser/renderer_host/quota_dispatcher_host.cc

@ -4,6 +4,7 @@
#include "content/browser/renderer_host/quota_dispatcher_host.h"
#include "base/bind.h"
#include "base/memory/scoped_callback_factory.h"
#include "content/browser/quota_permission_context.h"
#include "content/common/quota_messages.h"
@ -57,13 +58,14 @@ class QuotaDispatcherHost::QueryUsageAndQuotaDispatcher
QuotaDispatcherHost* dispatcher_host,
int request_id)
: RequestDispatcher(dispatcher_host, request_id),
callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {}
weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {}
virtual ~QueryUsageAndQuotaDispatcher() {}
void QueryStorageUsageAndQuota(const GURL& origin, StorageType type) {
quota_manager()->GetUsageAndQuota(origin, type,
callback_factory_.NewCallback(
&QueryUsageAndQuotaDispatcher::DidQueryStorageUsageAndQuota));
quota_manager()->GetUsageAndQuota(
origin, type,
base::Bind(&QueryUsageAndQuotaDispatcher::DidQueryStorageUsageAndQuota,
weak_factory_.GetWeakPtr()));
}
private:
@ -79,7 +81,7 @@ class QuotaDispatcherHost::QueryUsageAndQuotaDispatcher
Completed();
}
base::ScopedCallbackFactory<QueryUsageAndQuotaDispatcher> callback_factory_;
base::WeakPtrFactory<QueryUsageAndQuotaDispatcher> weak_factory_;
};
class QuotaDispatcherHost::RequestQuotaDispatcher
@ -100,6 +102,7 @@ class QuotaDispatcherHost::RequestQuotaDispatcher
current_quota_(0),
requested_quota_(requested_quota),
render_view_id_(render_view_id),
weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {}
virtual ~RequestQuotaDispatcher() {}
@ -109,12 +112,13 @@ class QuotaDispatcherHost::RequestQuotaDispatcher
if (type_ == quota::kStorageTypePersistent) {
quota_manager()->GetPersistentHostQuota(
host_,
callback_factory_.NewCallback(&self_type::DidGetHostQuota));
base::Bind(&self_type::DidGetHostQuota,
weak_factory_.GetWeakPtr()));
} else {
quota_manager()->GetUsageAndQuota(
origin_, type_,
callback_factory_.NewCallback(
&self_type::DidGetTemporaryUsageAndQuota));
base::Bind(&self_type::DidGetTemporaryUsageAndQuota,
weak_factory_.GetWeakPtr()));
}
}
@ -158,7 +162,8 @@ class QuotaDispatcherHost::RequestQuotaDispatcher
// Now we're allowed to set the new quota.
quota_manager()->SetPersistentHostQuota(
host_, requested_quota_,
callback_factory_.NewCallback(&self_type::DidSetHostQuota));
base::Bind(&self_type::DidSetHostQuota,
weak_factory_.GetWeakPtr()));
}
void DidSetHostQuota(QuotaStatusCode status,
@ -187,6 +192,7 @@ class QuotaDispatcherHost::RequestQuotaDispatcher
int64 current_quota_;
const int64 requested_quota_;
const int render_view_id_;
base::WeakPtrFactory<self_type> weak_factory_;
base::ScopedCallbackFactory<self_type> callback_factory_;
};

93
webkit/appcache/appcache_quota_client.cc

@ -6,6 +6,7 @@
#include <algorithm>
#include <map>
#include <set>
#include "webkit/appcache/appcache_service.h"
@ -36,7 +37,7 @@ AppCacheQuotaClient::~AppCacheQuotaClient() {
DCHECK(pending_usage_requests_.empty());
DCHECK(pending_origins_requests_.empty());
DCHECK(pending_delete_requests_.empty());
DCHECK(!current_delete_request_callback_.get());
DCHECK(current_delete_request_callback_.is_null());
}
QuotaClient::ID AppCacheQuotaClient::id() const {
@ -45,8 +46,8 @@ QuotaClient::ID AppCacheQuotaClient::id() const {
void AppCacheQuotaClient::OnQuotaManagerDestroyed() {
DeletePendingRequests();
if (current_delete_request_callback_.get()) {
current_delete_request_callback_.reset();
if (!current_delete_request_callback_.is_null()) {
current_delete_request_callback_.Reset();
service_delete_callback_.release()->Cancel();
} else {
service_delete_callback_ = NULL;
@ -59,13 +60,12 @@ void AppCacheQuotaClient::OnQuotaManagerDestroyed() {
void AppCacheQuotaClient::GetOriginUsage(
const GURL& origin,
quota::StorageType type,
GetUsageCallback* callback_ptr) {
DCHECK(callback_ptr);
const GetUsageCallback& callback) {
DCHECK(!callback.is_null());
DCHECK(!quota_manager_is_destroyed_);
scoped_ptr<GetUsageCallback> callback(callback_ptr);
if (!service_) {
callback->Run(0);
callback.Run(0);
return;
}
@ -73,64 +73,61 @@ void AppCacheQuotaClient::GetOriginUsage(
pending_usage_requests_.push_back(UsageRequest());
pending_usage_requests_.back().origin = origin;
pending_usage_requests_.back().type = type;
pending_usage_requests_.back().callback = callback.release();
pending_usage_requests_.back().callback = callback;
return;
}
if (type == quota::kStorageTypePersistent) {
callback->Run(0);
callback.Run(0);
return;
}
const AppCacheStorage::UsageMap* map = GetUsageMap();
AppCacheStorage::UsageMap::const_iterator found = map->find(origin);
if (found == map->end()) {
callback->Run(0);
callback.Run(0);
return;
}
callback->Run(found->second);
callback.Run(found->second);
}
void AppCacheQuotaClient::GetOriginsForType(
quota::StorageType type,
GetOriginsCallback* callback_ptr) {
GetOriginsHelper(type, std::string(), callback_ptr);
const GetOriginsCallback& callback) {
GetOriginsHelper(type, std::string(), callback);
}
void AppCacheQuotaClient::GetOriginsForHost(
quota::StorageType type,
const std::string& host,
GetOriginsCallback* callback_ptr) {
DCHECK(callback_ptr);
const GetOriginsCallback& callback) {
DCHECK(!callback.is_null());
if (host.empty()) {
callback_ptr->Run(std::set<GURL>(), type);
delete callback_ptr;
callback.Run(std::set<GURL>(), type);
return;
}
GetOriginsHelper(type, host, callback_ptr);
GetOriginsHelper(type, host, callback);
}
void AppCacheQuotaClient::DeleteOriginData(const GURL& origin,
quota::StorageType type,
DeletionCallback* callback_ptr) {
DCHECK(callback_ptr);
const DeletionCallback& callback) {
DCHECK(!quota_manager_is_destroyed_);
scoped_ptr<DeletionCallback> callback(callback_ptr);
if (!service_) {
callback->Run(quota::kQuotaErrorAbort);
callback.Run(quota::kQuotaErrorAbort);
return;
}
if (!appcache_is_ready_ || current_delete_request_callback_.get()) {
if (!appcache_is_ready_ || !current_delete_request_callback_.is_null()) {
pending_delete_requests_.push_back(DeleteRequest());
pending_delete_requests_.back().origin = origin;
pending_delete_requests_.back().type = type;
pending_delete_requests_.back().callback = callback.release();
pending_delete_requests_.back().callback = callback;
return;
}
current_delete_request_callback_.swap(callback);
current_delete_request_callback_ = callback;
if (type == quota::kStorageTypePersistent) {
DidDeleteAppCachesForOrigin(net::OK);
return;
@ -138,20 +135,29 @@ void AppCacheQuotaClient::DeleteOriginData(const GURL& origin,
service_->DeleteAppCachesForOrigin(origin, service_delete_callback_);
}
AppCacheQuotaClient::UsageRequest::UsageRequest() {}
AppCacheQuotaClient::UsageRequest::~UsageRequest() {}
AppCacheQuotaClient::OriginsRequest::OriginsRequest() {}
AppCacheQuotaClient::OriginsRequest::~OriginsRequest() {}
AppCacheQuotaClient::DeleteRequest::DeleteRequest() {}
AppCacheQuotaClient::DeleteRequest::~DeleteRequest() {}
void AppCacheQuotaClient::DidDeleteAppCachesForOrigin(int rv) {
DCHECK(service_);
if (quota_manager_is_destroyed_)
return;
// Finish the request by calling our callers callback.
current_delete_request_callback_->Run(NetErrorCodeToQuotaStatus(rv));
current_delete_request_callback_.reset();
current_delete_request_callback_.Run(NetErrorCodeToQuotaStatus(rv));
current_delete_request_callback_.Reset();
if (pending_delete_requests_.empty())
return;
// Start the next in the queue.
DeleteRequest& next_request = pending_delete_requests_.front();
current_delete_request_callback_.reset(next_request.callback);
current_delete_request_callback_ = next_request.callback;
service_->DeleteAppCachesForOrigin(next_request.origin,
service_delete_callback_);
pending_delete_requests_.pop_front();
@ -160,13 +166,12 @@ void AppCacheQuotaClient::DidDeleteAppCachesForOrigin(int rv) {
void AppCacheQuotaClient::GetOriginsHelper(
quota::StorageType type,
const std::string& opt_host,
GetOriginsCallback* callback_ptr) {
DCHECK(callback_ptr);
const GetOriginsCallback& callback) {
DCHECK(!callback.is_null());
DCHECK(!quota_manager_is_destroyed_);
scoped_ptr<GetOriginsCallback> callback(callback_ptr);
if (!service_) {
callback->Run(std::set<GURL>(), type);
callback.Run(std::set<GURL>(), type);
return;
}
@ -174,12 +179,12 @@ void AppCacheQuotaClient::GetOriginsHelper(
pending_origins_requests_.push_back(OriginsRequest());
pending_origins_requests_.back().opt_host = opt_host;
pending_origins_requests_.back().type = type;
pending_origins_requests_.back().callback = callback.release();
pending_origins_requests_.back().callback = callback;
return;
}
if (type == quota::kStorageTypePersistent) {
callback->Run(std::set<GURL>(), type);
callback.Run(std::set<GURL>(), type);
return;
}
@ -190,7 +195,7 @@ void AppCacheQuotaClient::GetOriginsHelper(
if (opt_host.empty() || iter->first.host() == opt_host)
origins.insert(iter->first);
}
callback->Run(origins, type);
callback.Run(origins, type);
}
void AppCacheQuotaClient::ProcessPendingRequests() {
@ -215,34 +220,28 @@ void AppCacheQuotaClient::ProcessPendingRequests() {
void AppCacheQuotaClient::AbortPendingRequests() {
while (!pending_usage_requests_.empty()) {
pending_usage_requests_.front().callback->Run(0);
delete pending_usage_requests_.front().callback;
pending_usage_requests_.front().callback.Run(0);
pending_usage_requests_.pop_front();
}
while (!pending_origins_requests_.empty()) {
pending_origins_requests_.front().callback->Run(std::set<GURL>(),
pending_origins_requests_.front().callback.Run(std::set<GURL>(),
pending_origins_requests_.front().type);
delete pending_origins_requests_.front().callback;
pending_origins_requests_.pop_front();
}
while (!pending_delete_requests_.empty()) {
pending_delete_requests_.front().callback->Run(quota::kQuotaErrorAbort);
delete pending_delete_requests_.front().callback;
pending_delete_requests_.front().callback.Run(quota::kQuotaErrorAbort);
pending_delete_requests_.pop_front();
}
}
void AppCacheQuotaClient::DeletePendingRequests() {
while (!pending_usage_requests_.empty()) {
delete pending_usage_requests_.front().callback;
pending_usage_requests_.pop_front();
}
while (!pending_origins_requests_.empty()) {
delete pending_origins_requests_.front().callback;
pending_origins_requests_.pop_front();
}
while (!pending_delete_requests_.empty()) {
delete pending_delete_requests_.front().callback;
pending_delete_requests_.pop_front();
}
}
@ -260,9 +259,9 @@ void AppCacheQuotaClient::NotifyAppCacheReady() {
void AppCacheQuotaClient::NotifyAppCacheDestroyed() {
service_ = NULL;
AbortPendingRequests();
if (current_delete_request_callback_.get()) {
current_delete_request_callback_->Run(quota::kQuotaErrorAbort);
current_delete_request_callback_.reset();
if (!current_delete_request_callback_.is_null()) {
current_delete_request_callback_.Run(quota::kQuotaErrorAbort);
current_delete_request_callback_.Reset();
service_delete_callback_.release()->Cancel();
} else {
service_delete_callback_ = NULL;

27
webkit/appcache/appcache_quota_client.h

@ -39,15 +39,15 @@ class AppCacheQuotaClient : public quota::QuotaClient {
virtual void OnQuotaManagerDestroyed();
virtual void GetOriginUsage(const GURL& origin,
quota::StorageType type,
GetUsageCallback* callback) OVERRIDE;
const GetUsageCallback& callback) OVERRIDE;
virtual void GetOriginsForType(quota::StorageType type,
GetOriginsCallback* callback) OVERRIDE;
const GetOriginsCallback& callback) OVERRIDE;
virtual void GetOriginsForHost(quota::StorageType type,
const std::string& host,
GetOriginsCallback* callback) OVERRIDE;
const GetOriginsCallback& callback) OVERRIDE;
virtual void DeleteOriginData(const GURL& origin,
quota::StorageType type,
DeletionCallback* callback) OVERRIDE;
const DeletionCallback& callback) OVERRIDE;
private:
friend class AppCacheService; // for NotifyAppCacheIsDestroyed
@ -57,17 +57,26 @@ class AppCacheQuotaClient : public quota::QuotaClient {
struct UsageRequest {
GURL origin;
quota::StorageType type;
GetUsageCallback* callback;
GetUsageCallback callback;
UsageRequest();
~UsageRequest();
};
struct OriginsRequest {
quota::StorageType type;
std::string opt_host;
GetOriginsCallback* callback;
GetOriginsCallback callback;
OriginsRequest();
~OriginsRequest();
};
struct DeleteRequest {
GURL origin;
quota::StorageType type;
DeletionCallback* callback;
DeletionCallback callback;
DeleteRequest();
~DeleteRequest();
};
typedef std::deque<UsageRequest> UsageRequestQueue;
typedef std::deque<OriginsRequest> OriginsRequestQueue;
@ -78,7 +87,7 @@ class AppCacheQuotaClient : public quota::QuotaClient {
void DidDeleteAppCachesForOrigin(int rv);
void GetOriginsHelper(quota::StorageType type,
const std::string& opt_host,
GetOriginsCallback* callback_ptr);
const GetOriginsCallback& callback);
void ProcessPendingRequests();
void AbortPendingRequests();
void DeletePendingRequests();
@ -96,7 +105,7 @@ class AppCacheQuotaClient : public quota::QuotaClient {
// And once it's ready, we can only handle one delete request at a time,
// so we queue up additional requests while one is in already in progress.
scoped_ptr<DeletionCallback> current_delete_request_callback_;
DeletionCallback current_delete_request_callback_;
scoped_refptr<net::CancelableOldCompletionCallback<AppCacheQuotaClient> >
service_delete_callback_;

34
webkit/appcache/appcache_quota_client_unittest.cc

@ -3,7 +3,9 @@
// found in the LICENSE file.
#include <map>
#include <set>
#include "base/bind.h"
#include "base/memory/scoped_callback_factory.h"
#include "base/message_loop.h"
#include "base/message_loop_proxy.h"
@ -34,7 +36,7 @@ class AppCacheQuotaClientTest : public testing::Test {
num_get_origin_usage_completions_(0),
num_get_origins_completions_(0),
num_delete_origins_completions_(0),
callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
}
int64 GetOriginUsage(
@ -80,35 +82,39 @@ class AppCacheQuotaClientTest : public testing::Test {
quota::QuotaClient* client,
const GURL& origin,
quota::StorageType type) {
client->GetOriginUsage(origin, type,
callback_factory_.NewCallback(
&AppCacheQuotaClientTest::OnGetOriginUsageComplete));
client->GetOriginUsage(
origin, type,
base::Bind(&AppCacheQuotaClientTest::OnGetOriginUsageComplete,
weak_factory_.GetWeakPtr()));
}
void AsyncGetOriginsForType(
quota::QuotaClient* client,
quota::StorageType type) {
client->GetOriginsForType(type,
callback_factory_.NewCallback(
&AppCacheQuotaClientTest::OnGetOriginsComplete));
client->GetOriginsForType(
type,
base::Bind(&AppCacheQuotaClientTest::OnGetOriginsComplete,
weak_factory_.GetWeakPtr()));
}
void AsyncGetOriginsForHost(
quota::QuotaClient* client,
quota::StorageType type,
const std::string& host) {
client->GetOriginsForHost(type, host,
callback_factory_.NewCallback(
&AppCacheQuotaClientTest::OnGetOriginsComplete));
client->GetOriginsForHost(
type, host,
base::Bind(&AppCacheQuotaClientTest::OnGetOriginsComplete,
weak_factory_.GetWeakPtr()));
}
void AsyncDeleteOriginData(
quota::QuotaClient* client,
quota::StorageType type,
const GURL& origin) {
client->DeleteOriginData(origin, type,
callback_factory_.NewCallback(
&AppCacheQuotaClientTest::OnDeleteOriginDataComplete));
client->DeleteOriginData(
origin, type,
base::Bind(&AppCacheQuotaClientTest::OnDeleteOriginDataComplete,
weak_factory_.GetWeakPtr()));
}
void SetUsageMapEntry(const GURL& origin, int64 usage) {
@ -157,7 +163,7 @@ class AppCacheQuotaClientTest : public testing::Test {
int num_get_origins_completions_;
int num_delete_origins_completions_;
MockAppCacheService mock_service_;
base::ScopedCallbackFactory<AppCacheQuotaClientTest> callback_factory_;
base::WeakPtrFactory<AppCacheQuotaClientTest> weak_factory_;
};

7
webkit/appcache/appcache_storage_impl.cc

@ -4,8 +4,12 @@
#include "webkit/appcache/appcache_storage_impl.h"
#include <algorithm>
#include <functional>
#include <set>
#include <vector>
#include "base/bind.h"
#include "base/file_util.h"
#include "base/logging.h"
#include "base/message_loop.h"
@ -549,7 +553,8 @@ void AppCacheStorageImpl::StoreGroupAndCacheTask::GetQuotaThenSchedule() {
storage_->pending_quota_queries_.insert(this);
quota_manager->GetUsageAndQuota(
group_record_.origin, quota::kStorageTypeTemporary,
NewCallback(this, &StoreGroupAndCacheTask::OnQuotaCallback));
base::Bind(&StoreGroupAndCacheTask::OnQuotaCallback,
base::Unretained(this)));
}
void AppCacheStorageImpl::StoreGroupAndCacheTask::OnQuotaCallback(

1
webkit/appcache/appcache_storage_impl.h

@ -8,6 +8,7 @@
#include <deque>
#include <map>
#include <set>
#include <utility>
#include <vector>
#include "base/file_path.h"

23
webkit/appcache/appcache_storage_impl_unittest.cc

@ -131,21 +131,20 @@ class AppCacheStorageImplTest : public testing::Test {
virtual void GetUsageAndQuota(
const GURL& origin, quota::StorageType type,
GetUsageAndQuotaCallback* callback) {
const GetUsageAndQuotaCallback& callback) OVERRIDE {
EXPECT_EQ(kOrigin, origin);
EXPECT_EQ(quota::kStorageTypeTemporary, type);
if (async_) {
MessageLoop::current()->PostTask(FROM_HERE,
NewRunnableMethod(this, &MockQuotaManager::CallCallbackAndDelete,
NewRunnableMethod(this, &MockQuotaManager::CallCallback,
callback));
return;
}
CallCallbackAndDelete(callback);
CallCallback(callback);
}
void CallCallbackAndDelete(GetUsageAndQuotaCallback* callback) {
callback->Run(quota::kQuotaStatusOk, 0, kMockQuota);
delete callback;
void CallCallback(const GetUsageAndQuotaCallback& callback) {
callback.Run(quota::kQuotaStatusOk, 0, kMockQuota);
}
bool async_;
@ -164,7 +163,7 @@ class AppCacheStorageImplTest : public testing::Test {
virtual void NotifyStorageAccessed(quota::QuotaClient::ID client_id,
const GURL& origin,
quota::StorageType type) {
quota::StorageType type) OVERRIDE {
EXPECT_EQ(quota::QuotaClient::kAppcache, client_id);
EXPECT_EQ(quota::kStorageTypeTemporary, type);
++notify_storage_accessed_count_;
@ -174,7 +173,7 @@ class AppCacheStorageImplTest : public testing::Test {
virtual void NotifyStorageModified(quota::QuotaClient::ID client_id,
const GURL& origin,
quota::StorageType type,
int64 delta) {
int64 delta) OVERRIDE {
EXPECT_EQ(quota::QuotaClient::kAppcache, client_id);
EXPECT_EQ(quota::kStorageTypeTemporary, type);
++notify_storage_modified_count_;
@ -183,9 +182,9 @@ class AppCacheStorageImplTest : public testing::Test {
}
// Not needed for our tests.
virtual void RegisterClient(quota::QuotaClient* client) {}
virtual void NotifyOriginInUse(const GURL& origin) {}
virtual void NotifyOriginNoLongerInUse(const GURL& origin) {}
virtual void RegisterClient(quota::QuotaClient* client) OVERRIDE {}
virtual void NotifyOriginInUse(const GURL& origin) OVERRIDE {}
virtual void NotifyOriginNoLongerInUse(const GURL& origin) OVERRIDE {}
int notify_storage_accessed_count_;
int notify_storage_modified_count_;
@ -203,7 +202,7 @@ class AppCacheStorageImplTest : public testing::Test {
: test_(test), method_(method) {
}
virtual void Run() {
virtual void Run() OVERRIDE {
test_->SetUpTest();
// Ensure InitTask execution prior to conducting a test.

48
webkit/database/database_quota_client.cc

@ -137,7 +137,7 @@ class DatabaseQuotaClient::DeleteOriginTask : public HelperTask {
DatabaseQuotaClient* client,
base::MessageLoopProxy* db_tracker_thread,
const GURL& origin_url,
DeletionCallback* caller_callback)
const DeletionCallback& caller_callback)
: HelperTask(client, db_tracker_thread),
origin_url_(origin_url),
result_(quota::kQuotaStatusUnknown),
@ -148,14 +148,14 @@ class DatabaseQuotaClient::DeleteOriginTask : public HelperTask {
private:
virtual void Completed() OVERRIDE {
if (!caller_callback_.get())
if (caller_callback_.is_null())
return;
caller_callback_->Run(result_);
caller_callback_.reset();
caller_callback_.Run(result_);
caller_callback_.Reset();
}
virtual void Aborted() OVERRIDE {
caller_callback_.reset();
caller_callback_.Reset();
}
virtual bool RunOnTargetThreadAsync() OVERRIDE {
@ -178,7 +178,7 @@ class DatabaseQuotaClient::DeleteOriginTask : public HelperTask {
const GURL origin_url_;
quota::QuotaStatusCode result_;
scoped_ptr<DeletionCallback> caller_callback_;
DeletionCallback caller_callback_;
net::OldCompletionCallbackImpl<DeleteOriginTask> completion_callback_;
};
@ -204,18 +204,17 @@ void DatabaseQuotaClient::OnQuotaManagerDestroyed() {
void DatabaseQuotaClient::GetOriginUsage(
const GURL& origin_url,
quota::StorageType type,
GetUsageCallback* callback_ptr) {
DCHECK(callback_ptr);
const GetUsageCallback& callback) {
DCHECK(!callback.is_null());
DCHECK(db_tracker_.get());
scoped_ptr<GetUsageCallback> callback(callback_ptr);
// All databases are in the temp namespace for now.
if (type != quota::kStorageTypeTemporary) {
callback->Run(0);
callback.Run(0);
return;
}
if (usage_for_origin_callbacks_.Add(origin_url, callback.release())) {
if (usage_for_origin_callbacks_.Add(origin_url, callback)) {
scoped_refptr<GetOriginUsageTask> task(
new GetOriginUsageTask(this, db_tracker_thread_, origin_url));
task->Start();
@ -224,18 +223,17 @@ void DatabaseQuotaClient::GetOriginUsage(
void DatabaseQuotaClient::GetOriginsForType(
quota::StorageType type,
GetOriginsCallback* callback_ptr) {
DCHECK(callback_ptr);
const GetOriginsCallback& callback) {
DCHECK(!callback.is_null());
DCHECK(db_tracker_.get());
scoped_ptr<GetOriginsCallback> callback(callback_ptr);
// All databases are in the temp namespace for now.
if (type != quota::kStorageTypeTemporary) {
callback->Run(std::set<GURL>(), type);
callback.Run(std::set<GURL>(), type);
return;
}
if (origins_for_type_callbacks_.Add(callback.release())) {
if (origins_for_type_callbacks_.Add(callback)) {
scoped_refptr<GetAllOriginsTask> task(
new GetAllOriginsTask(this, db_tracker_thread_, type));
task->Start();
@ -245,18 +243,17 @@ void DatabaseQuotaClient::GetOriginsForType(
void DatabaseQuotaClient::GetOriginsForHost(
quota::StorageType type,
const std::string& host,
GetOriginsCallback* callback_ptr) {
DCHECK(callback_ptr);
const GetOriginsCallback& callback) {
DCHECK(!callback.is_null());
DCHECK(db_tracker_.get());
scoped_ptr<GetOriginsCallback> callback(callback_ptr);
// All databases are in the temp namespace for now.
if (type != quota::kStorageTypeTemporary) {
callback->Run(std::set<GURL>(), type);
callback.Run(std::set<GURL>(), type);
return;
}
if (origins_for_host_callbacks_.Add(host, callback.release())) {
if (origins_for_host_callbacks_.Add(host, callback)) {
scoped_refptr<GetOriginsForHostTask> task(
new GetOriginsForHostTask(this, db_tracker_thread_, host, type));
task->Start();
@ -265,20 +262,19 @@ void DatabaseQuotaClient::GetOriginsForHost(
void DatabaseQuotaClient::DeleteOriginData(const GURL& origin,
quota::StorageType type,
DeletionCallback* callback_ptr) {
DCHECK(callback_ptr);
const DeletionCallback& callback) {
DCHECK(!callback.is_null());
DCHECK(db_tracker_.get());
scoped_ptr<DeletionCallback> callback(callback_ptr);
// All databases are in the temp namespace for now, so nothing to delete.
if (type != quota::kStorageTypeTemporary) {
callback->Run(quota::kQuotaStatusOk);
callback.Run(quota::kQuotaStatusOk);
return;
}
scoped_refptr<DeleteOriginTask> task(
new DeleteOriginTask(this, db_tracker_thread_,
origin, callback.release()));
origin, callback));
task->Start();
}

14
webkit/database/database_quota_client.h

@ -34,15 +34,15 @@ class DatabaseQuotaClient : public quota::QuotaClient,
virtual void OnQuotaManagerDestroyed();
virtual void GetOriginUsage(const GURL& origin_url,
quota::StorageType type,
GetUsageCallback* callback) OVERRIDE;
const GetUsageCallback& callback) OVERRIDE;
virtual void GetOriginsForType(quota::StorageType type,
GetOriginsCallback* callback) OVERRIDE;
const GetOriginsCallback& callback) OVERRIDE;
virtual void GetOriginsForHost(quota::StorageType type,
const std::string& host,
GetOriginsCallback* callback) OVERRIDE;
const GetOriginsCallback& callback) OVERRIDE;
virtual void DeleteOriginData(const GURL& origin,
quota::StorageType type,
DeletionCallback* callback) OVERRIDE;
const DeletionCallback& callback) OVERRIDE;
private:
class HelperTask;
class GetOriginUsageTask;
@ -52,17 +52,17 @@ class DatabaseQuotaClient : public quota::QuotaClient,
class DeleteOriginTask;
typedef quota::CallbackQueueMap1
<GetUsageCallback*,
<GetUsageCallback,
GURL, // origin
int64
> UsageForOriginCallbackMap;
typedef quota::CallbackQueue2
<GetOriginsCallback*,
<GetOriginsCallback,
const std::set<GURL>&,
quota::StorageType
> OriginsForTypeCallbackQueue;
typedef quota::CallbackQueueMap2
<GetOriginsCallback*,
<GetOriginsCallback,
std::string, // host
const std::set<GURL>&,
quota::StorageType

34
webkit/database/database_quota_client_unittest.cc

@ -4,8 +4,8 @@
#include <map>
#include "base/bind.h"
#include "base/file_path.h"
#include "base/memory/scoped_callback_factory.h"
#include "base/message_loop.h"
#include "base/message_loop_proxy.h"
#include "base/utf_string_conversions.h"
@ -126,7 +126,7 @@ class DatabaseQuotaClientTest : public testing::Test {
kOriginOther("http://other"),
usage_(0),
mock_tracker_(new MockDatabaseTracker),
callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
}
int64 GetOriginUsage(
@ -134,9 +134,10 @@ class DatabaseQuotaClientTest : public testing::Test {
const GURL& origin,
quota::StorageType type) {
usage_ = 0;
client->GetOriginUsage(origin, type,
callback_factory_.NewCallback(
&DatabaseQuotaClientTest::OnGetOriginUsageComplete));
client->GetOriginUsage(
origin, type,
base::Bind(&DatabaseQuotaClientTest::OnGetOriginUsageComplete,
weak_factory_.GetWeakPtr()));
MessageLoop::current()->RunAllPending();
return usage_;
}
@ -145,9 +146,10 @@ class DatabaseQuotaClientTest : public testing::Test {
quota::QuotaClient* client,
quota::StorageType type) {
origins_.clear();
client->GetOriginsForType(type,
callback_factory_.NewCallback(
&DatabaseQuotaClientTest::OnGetOriginsComplete));
client->GetOriginsForType(
type,
base::Bind(&DatabaseQuotaClientTest::OnGetOriginsComplete,
weak_factory_.GetWeakPtr()));
MessageLoop::current()->RunAllPending();
return origins_;
}
@ -157,9 +159,10 @@ class DatabaseQuotaClientTest : public testing::Test {
quota::StorageType type,
const std::string& host) {
origins_.clear();
client->GetOriginsForHost(type, host,
callback_factory_.NewCallback(
&DatabaseQuotaClientTest::OnGetOriginsComplete));
client->GetOriginsForHost(
type, host,
base::Bind(&DatabaseQuotaClientTest::OnGetOriginsComplete,
weak_factory_.GetWeakPtr()));
MessageLoop::current()->RunAllPending();
return origins_;
}
@ -169,9 +172,10 @@ class DatabaseQuotaClientTest : public testing::Test {
quota::StorageType type,
const GURL& origin) {
delete_status_ = quota::kQuotaStatusUnknown;
client->DeleteOriginData(origin, type,
callback_factory_.NewCallback(
&DatabaseQuotaClientTest::OnDeleteOriginDataComplete));
client->DeleteOriginData(
origin, type,
base::Bind(&DatabaseQuotaClientTest::OnDeleteOriginDataComplete,
weak_factory_.GetWeakPtr()));
MessageLoop::current()->RunAllPending();
return delete_status_ == quota::kQuotaStatusOk;
}
@ -199,7 +203,7 @@ class DatabaseQuotaClientTest : public testing::Test {
quota::StorageType type_;
quota::QuotaStatusCode delete_status_;
scoped_refptr<MockDatabaseTracker> mock_tracker_;
base::ScopedCallbackFactory<DatabaseQuotaClientTest> callback_factory_;
base::WeakPtrFactory<DatabaseQuotaClientTest> weak_factory_;
};

47
webkit/fileapi/file_system_operation.cc

@ -122,8 +122,10 @@ void FileSystemOperation::CreateFile(const GURL& path,
file_system_operation_context_.set_src_file_util(file_util);
exclusive_ = exclusive;
GetUsageAndQuotaThenCallback(origin_url, callback_factory_.NewCallback(
&FileSystemOperation::DelayedCreateFileForQuota));
GetUsageAndQuotaThenCallback(
origin_url,
base::Bind(&FileSystemOperation::DelayedCreateFileForQuota,
weak_factory_.GetWeakPtr()));
}
void FileSystemOperation::DelayedCreateFileForQuota(
@ -168,8 +170,10 @@ void FileSystemOperation::CreateDirectory(const GURL& path,
exclusive_ = exclusive;
recursive_ = recursive;
GetUsageAndQuotaThenCallback(origin_url, callback_factory_.NewCallback(
&FileSystemOperation::DelayedCreateDirectoryForQuota));
GetUsageAndQuotaThenCallback(
origin_url,
base::Bind(&FileSystemOperation::DelayedCreateDirectoryForQuota,
weak_factory_.GetWeakPtr()));
}
void FileSystemOperation::DelayedCreateDirectoryForQuota(
@ -217,8 +221,10 @@ void FileSystemOperation::Copy(const GURL& src_path,
if (!file_system_operation_context_.dest_file_util())
file_system_operation_context_.set_dest_file_util(dest_file_util);
GetUsageAndQuotaThenCallback(dest_origin_url, callback_factory_.NewCallback(
&FileSystemOperation::DelayedCopyForQuota));
GetUsageAndQuotaThenCallback(
dest_origin_url,
base::Bind(&FileSystemOperation::DelayedCopyForQuota,
weak_factory_.GetWeakPtr()));
}
void FileSystemOperation::DelayedCopyForQuota(quota::QuotaStatusCode status,
@ -266,8 +272,10 @@ void FileSystemOperation::Move(const GURL& src_path,
if (!file_system_operation_context_.dest_file_util())
file_system_operation_context_.set_dest_file_util(dest_file_util);
GetUsageAndQuotaThenCallback(dest_origin_url, callback_factory_.NewCallback(
&FileSystemOperation::DelayedMoveForQuota));
GetUsageAndQuotaThenCallback(
dest_origin_url,
base::Bind(&FileSystemOperation::DelayedMoveForQuota,
weak_factory_.GetWeakPtr()));
}
void FileSystemOperation::DelayedMoveForQuota(quota::QuotaStatusCode status,
@ -438,8 +446,10 @@ void FileSystemOperation::Write(
new net::URLRequest(blob_url, file_writer_delegate_.get()));
blob_request_->set_context(url_request_context);
GetUsageAndQuotaThenCallback(origin_url, callback_factory_.NewCallback(
&FileSystemOperation::DelayedWriteForQuota));
GetUsageAndQuotaThenCallback(
origin_url,
base::Bind(&FileSystemOperation::DelayedWriteForQuota,
weak_factory_.GetWeakPtr()));
}
void FileSystemOperation::DelayedWriteForQuota(quota::QuotaStatusCode status,
@ -480,8 +490,10 @@ void FileSystemOperation::Truncate(const GURL& path, int64 length) {
file_system_operation_context_.set_src_file_util(file_util);
length_ = length;
GetUsageAndQuotaThenCallback(origin_url, callback_factory_.NewCallback(
&FileSystemOperation::DelayedTruncateForQuota));
GetUsageAndQuotaThenCallback(
origin_url,
base::Bind(&FileSystemOperation::DelayedTruncateForQuota,
weak_factory_.GetWeakPtr()));
}
void FileSystemOperation::DelayedTruncateForQuota(quota::QuotaStatusCode status,
@ -569,8 +581,10 @@ void FileSystemOperation::OpenFile(const GURL& path,
file_system_operation_context_.set_src_file_util(file_util);
file_flags_ = file_flags;
GetUsageAndQuotaThenCallback(origin_url, callback_factory_.NewCallback(
&FileSystemOperation::DelayedOpenFileForQuota));
GetUsageAndQuotaThenCallback(
origin_url,
base::Bind(&FileSystemOperation::DelayedOpenFileForQuota,
weak_factory_.GetWeakPtr()));
}
void FileSystemOperation::DelayedOpenFileForQuota(quota::QuotaStatusCode status,
@ -623,7 +637,7 @@ void FileSystemOperation::Cancel(FileSystemOperation* cancel_operation_ptr) {
void FileSystemOperation::GetUsageAndQuotaThenCallback(
const GURL& origin_url,
quota::QuotaManager::GetUsageAndQuotaCallback* callback) {
const quota::QuotaManager::GetUsageAndQuotaCallback& callback) {
quota::QuotaManagerProxy* quota_manager_proxy =
file_system_context()->quota_manager_proxy();
if (!quota_manager_proxy ||
@ -631,8 +645,7 @@ void FileSystemOperation::GetUsageAndQuotaThenCallback(
file_system_operation_context_.src_type())) {
// If we don't have the quota manager or the requested filesystem type
// does not support quota, we should be able to let it go.
callback->Run(quota::kQuotaStatusOk, 0, kint64max);
delete callback;
callback.Run(quota::kQuotaStatusOk, 0, kint64max);
return;
}
DCHECK(quota_manager_proxy);

2
webkit/fileapi/file_system_operation.h

@ -112,7 +112,7 @@ class FileSystemOperation {
void GetUsageAndQuotaThenCallback(
const GURL& origin_url,
quota::QuotaManager::GetUsageAndQuotaCallback* callback);
const quota::QuotaManager::GetUsageAndQuotaCallback& callback);
void DelayedCreateFileForQuota(quota::QuotaStatusCode status,
int64 usage, int64 quota);

7
webkit/fileapi/file_system_operation_unittest.cc

@ -51,11 +51,10 @@ class MockQuotaManager : public QuotaManager {
virtual void GetUsageAndQuota(
const GURL& origin, quota::StorageType type,
GetUsageAndQuotaCallback* callback) {
const GetUsageAndQuotaCallback& callback) OVERRIDE {
EXPECT_EQ(origin_, origin);
EXPECT_EQ(type_, type);
callback->Run(quota::kQuotaStatusOk, usage_, quota_);
delete callback;
callback.Run(quota::kQuotaStatusOk, usage_, quota_);
}
private:
@ -97,7 +96,7 @@ class MockQuotaManagerProxy : public QuotaManagerProxy {
EXPECT_FALSE(registered_client_);
}
virtual void RegisterClient(QuotaClient* client) {
virtual void RegisterClient(QuotaClient* client) OVERRIDE {
EXPECT_FALSE(registered_client_);
registered_client_ = client;
}

8
webkit/fileapi/file_system_operation_write_unittest.cc

@ -50,10 +50,10 @@ class MockQuotaManager : public QuotaManager {
usage_(0),
quota_(quota) {}
virtual void GetUsageAndQuota(const GURL& origin, quota::StorageType type,
GetUsageAndQuotaCallback* callback) {
callback->Run(quota::kQuotaStatusOk, usage_, quota_);
delete callback;
virtual void GetUsageAndQuota(
const GURL& origin, quota::StorageType type,
const GetUsageAndQuotaCallback& callback) OVERRIDE {
callback.Run(quota::kQuotaStatusOk, usage_, quota_);
}
void set_usage(int64 usage) { usage_ = usage; }

35
webkit/fileapi/file_system_quota_client.cc

@ -138,7 +138,7 @@ class FileSystemQuotaClient::DeleteOriginTask
scoped_refptr<MessageLoopProxy> file_message_loop,
const GURL& origin,
FileSystemType type,
DeletionCallback* callback)
const DeletionCallback& callback)
: QuotaThreadTask(quota_client, file_message_loop),
file_system_context_(quota_client->file_system_context_),
origin_(origin),
@ -158,14 +158,14 @@ class FileSystemQuotaClient::DeleteOriginTask
}
virtual void Completed() OVERRIDE {
callback_->Run(status_);
callback_.Run(status_);
}
private:
FileSystemContext* file_system_context_;
GURL origin_;
FileSystemType type_;
quota::QuotaStatusCode status_;
scoped_ptr<DeletionCallback> callback_;
DeletionCallback callback_;
};
FileSystemQuotaClient::FileSystemQuotaClient(
@ -192,13 +192,12 @@ void FileSystemQuotaClient::OnQuotaManagerDestroyed() {
void FileSystemQuotaClient::GetOriginUsage(
const GURL& origin_url,
StorageType storage_type,
GetUsageCallback* callback_ptr) {
DCHECK(callback_ptr);
scoped_ptr<GetUsageCallback> callback(callback_ptr);
const GetUsageCallback& callback) {
DCHECK(!callback.is_null());
if (is_incognito_) {
// We don't support FileSystem in incognito mode yet.
callback->Run(0);
callback.Run(0);
return;
}
@ -206,7 +205,7 @@ void FileSystemQuotaClient::GetOriginUsage(
DCHECK(type != kFileSystemTypeUnknown);
if (pending_usage_callbacks_.Add(
std::make_pair(type, origin_url.spec()), callback.release())) {
std::make_pair(type, origin_url.spec()), callback)) {
scoped_refptr<GetOriginUsageTask> task(
new GetOriginUsageTask(this, file_message_loop_, origin_url, type));
task->Start();
@ -215,19 +214,20 @@ void FileSystemQuotaClient::GetOriginUsage(
void FileSystemQuotaClient::GetOriginsForType(
StorageType storage_type,
GetOriginsCallback* callback_ptr) {
const GetOriginsCallback& callback) {
DCHECK(!callback.is_null());
std::set<GURL> origins;
scoped_ptr<GetOriginsCallback> callback(callback_ptr);
if (is_incognito_) {
// We don't support FileSystem in incognito mode yet.
callback->Run(origins, storage_type);
callback.Run(origins, storage_type);
return;
}
FileSystemType type = QuotaStorageTypeToFileSystemType(storage_type);
DCHECK(type != kFileSystemTypeUnknown);
if (pending_origins_for_type_callbacks_.Add(type, callback.release())) {
if (pending_origins_for_type_callbacks_.Add(type, callback)) {
scoped_refptr<GetOriginsForTypeTask> task(
new GetOriginsForTypeTask(this, file_message_loop_, type));
task->Start();
@ -237,12 +237,13 @@ void FileSystemQuotaClient::GetOriginsForType(
void FileSystemQuotaClient::GetOriginsForHost(
StorageType storage_type,
const std::string& host,
GetOriginsCallback* callback_ptr) {
const GetOriginsCallback& callback) {
DCHECK(!callback.is_null());
std::set<GURL> origins;
scoped_ptr<GetOriginsCallback> callback(callback_ptr);
if (is_incognito_) {
// We don't support FileSystem in incognito mode yet.
callback->Run(origins, storage_type);
callback.Run(origins, storage_type);
return;
}
@ -250,7 +251,7 @@ void FileSystemQuotaClient::GetOriginsForHost(
DCHECK(type != kFileSystemTypeUnknown);
if (pending_origins_for_host_callbacks_.Add(
std::make_pair(type, host), callback.release())) {
std::make_pair(type, host), callback)) {
scoped_refptr<GetOriginsForHostTask> task(
new GetOriginsForHostTask(this, file_message_loop_,
type, host));
@ -260,7 +261,7 @@ void FileSystemQuotaClient::GetOriginsForHost(
void FileSystemQuotaClient::DeleteOriginData(const GURL& origin,
StorageType type,
DeletionCallback* callback) {
const DeletionCallback& callback) {
FileSystemType fs_type = QuotaStorageTypeToFileSystemType(type);
DCHECK(fs_type != kFileSystemTypeUnknown);
scoped_refptr<DeleteOriginTask> task(

27
webkit/fileapi/file_system_quota_client.h

@ -43,15 +43,18 @@ class FileSystemQuotaClient : public quota::QuotaClient,
virtual void OnQuotaManagerDestroyed() OVERRIDE;
virtual void GetOriginUsage(const GURL& origin_url,
quota::StorageType type,
GetUsageCallback* callback) OVERRIDE;
virtual void GetOriginsForType(quota::StorageType type,
GetOriginsCallback* callback) OVERRIDE;
virtual void GetOriginsForHost(quota::StorageType type,
const std::string& host,
GetOriginsCallback* callback) OVERRIDE;
virtual void DeleteOriginData(const GURL& origin,
quota::StorageType type,
DeletionCallback* callback) OVERRIDE;
const GetUsageCallback& callback) OVERRIDE;
virtual void GetOriginsForType(
quota::StorageType type,
const GetOriginsCallback& callback) OVERRIDE;
virtual void GetOriginsForHost(
quota::StorageType type,
const std::string& host,
const GetOriginsCallback& callback) OVERRIDE;
virtual void DeleteOriginData(
const GURL& origin,
quota::StorageType type,
const DeletionCallback& callback) OVERRIDE;
private:
class GetOriginUsageTask;
@ -61,16 +64,16 @@ class FileSystemQuotaClient : public quota::QuotaClient,
class DeleteOriginTask;
typedef std::pair<fileapi::FileSystemType, std::string> TypeAndHostOrOrigin;
typedef quota::CallbackQueueMap1<GetUsageCallback*,
typedef quota::CallbackQueueMap1<GetUsageCallback,
TypeAndHostOrOrigin,
int64
> UsageCallbackMap;
typedef quota::CallbackQueueMap2<GetOriginsCallback*,
typedef quota::CallbackQueueMap2<GetOriginsCallback,
fileapi::FileSystemType,
const std::set<GURL>&,
quota::StorageType
> OriginsForTypeCallbackMap;
typedef quota::CallbackQueueMap2<GetOriginsCallback*,
typedef quota::CallbackQueueMap2<GetOriginsCallback,
TypeAndHostOrOrigin,
const std::set<GURL>&,
quota::StorageType

38
webkit/fileapi/file_system_quota_client_unittest.cc

@ -2,9 +2,9 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/bind.h"
#include "base/basictypes.h"
#include "base/file_util.h"
#include "base/memory/scoped_callback_factory.h"
#include "base/message_loop.h"
#include "base/message_loop_proxy.h"
#include "base/platform_file.h"
@ -45,7 +45,7 @@ class MockFileSystemPathManager : public FileSystemPathManager {
class FileSystemQuotaClientTest : public testing::Test {
public:
FileSystemQuotaClientTest()
: callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
: weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
additional_callback_count_(0),
deletion_status_(quota::kQuotaStatusUnknown) {
}
@ -79,9 +79,10 @@ class FileSystemQuotaClientTest : public testing::Test {
void GetOriginUsageAsync(FileSystemQuotaClient* quota_client,
const std::string& origin_url,
quota::StorageType type) {
quota_client->GetOriginUsage(GURL(origin_url), type,
callback_factory_.NewCallback(
&FileSystemQuotaClientTest::OnGetUsage));
quota_client->GetOriginUsage(
GURL(origin_url), type,
base::Bind(&FileSystemQuotaClientTest::OnGetUsage,
weak_factory_.GetWeakPtr()));
}
int64 GetOriginUsage(FileSystemQuotaClient* quota_client,
@ -95,9 +96,10 @@ class FileSystemQuotaClientTest : public testing::Test {
const std::set<GURL>& GetOriginsForType(FileSystemQuotaClient* quota_client,
quota::StorageType type) {
origins_.clear();
quota_client->GetOriginsForType(type,
callback_factory_.NewCallback(
&FileSystemQuotaClientTest::OnGetOrigins));
quota_client->GetOriginsForType(
type,
base::Bind(&FileSystemQuotaClientTest::OnGetOrigins,
weak_factory_.GetWeakPtr()));
MessageLoop::current()->RunAllPending();
return origins_;
}
@ -106,9 +108,10 @@ class FileSystemQuotaClientTest : public testing::Test {
quota::StorageType type,
const std::string& host) {
origins_.clear();
quota_client->GetOriginsForHost(type, host,
callback_factory_.NewCallback(
&FileSystemQuotaClientTest::OnGetOrigins));
quota_client->GetOriginsForHost(
type, host,
base::Bind(&FileSystemQuotaClientTest::OnGetOrigins,
weak_factory_.GetWeakPtr()));
MessageLoop::current()->RunAllPending();
return origins_;
}
@ -116,9 +119,10 @@ class FileSystemQuotaClientTest : public testing::Test {
void RunAdditionalOriginUsageTask(FileSystemQuotaClient* quota_client,
const std::string& origin_url,
quota::StorageType type) {
quota_client->GetOriginUsage(GURL(origin_url), type,
callback_factory_.NewCallback(
&FileSystemQuotaClientTest::OnGetAdditionalUsage));
quota_client->GetOriginUsage(
GURL(origin_url), type,
base::Bind(&FileSystemQuotaClientTest::OnGetAdditionalUsage,
weak_factory_.GetWeakPtr()));
}
FilePath GetOriginBasePath(const std::string& origin_url,
@ -234,8 +238,8 @@ class FileSystemQuotaClientTest : public testing::Test {
deletion_status_ = quota::kQuotaStatusUnknown;
quota_client->DeleteOriginData(
GURL(origin), type,
callback_factory_.NewCallback(
&FileSystemQuotaClientTest::OnDeleteOrigin));
base::Bind(&FileSystemQuotaClientTest::OnDeleteOrigin,
weak_factory_.GetWeakPtr()));
}
int64 usage() const { return usage_; }
@ -266,7 +270,7 @@ class FileSystemQuotaClientTest : public testing::Test {
ScopedTempDir data_dir_;
scoped_refptr<FileSystemContext> file_system_context_;
base::ScopedCallbackFactory<FileSystemQuotaClientTest> callback_factory_;
base::WeakPtrFactory<FileSystemQuotaClientTest> weak_factory_;
int64 usage_;
int additional_callback_count_;
std::set<GURL> origins_;

9
webkit/fileapi/file_system_quota_unittest.cc

@ -7,6 +7,7 @@
// 2) the described size in .usage, and
// 3) the result of QuotaManager::GetUsageAndQuota.
#include "base/bind.h"
#include "base/file_util.h"
#include "base/logging.h"
#include "base/memory/scoped_callback_factory.h"
@ -32,7 +33,7 @@ class FileSystemQuotaTest : public testing::Test {
public:
FileSystemQuotaTest()
: local_file_util_(new LocalFileUtil(QuotaFileUtil::CreateDefault())),
callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
status_(kFileOperationStatusNotSet),
quota_status_(quota::kQuotaStatusUnknown),
usage_(-1),
@ -74,8 +75,8 @@ class FileSystemQuotaTest : public testing::Test {
void GetUsageAndQuotaFromQuotaManager() {
quota_manager_->GetUsageAndQuota(
test_helper_.origin(), test_helper_.storage_type(),
callback_factory_.NewCallback(
&FileSystemQuotaTest::OnGetUsageAndQuota));
base::Bind(&FileSystemQuotaTest::OnGetUsageAndQuota,
weak_factory_.GetWeakPtr()));
MessageLoop::current()->RunAllPending();
}
@ -122,7 +123,7 @@ class FileSystemQuotaTest : public testing::Test {
scoped_refptr<quota::QuotaManager> quota_manager_;
scoped_ptr<LocalFileUtil> local_file_util_;
base::ScopedCallbackFactory<FileSystemQuotaTest> callback_factory_;
base::WeakPtrFactory<FileSystemQuotaTest> weak_factory_;
// For post-operation status.
int status_;

11
webkit/fileapi/obfuscated_file_util_unittest.cc

@ -6,10 +6,10 @@
#include <set>
#include <string>
#include "base/bind.h"
#include "base/file_path.h"
#include "base/file_util.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/scoped_callback_factory.h"
#include "base/message_loop.h"
#include "base/platform_file.h"
#include "base/scoped_temp_dir.h"
@ -133,7 +133,7 @@ class ObfuscatedFileUtilTest : public testing::Test {
ObfuscatedFileUtilTest()
: origin_(GURL("http://www.example.com")),
type_(kFileSystemTypeTemporary),
callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
test_helper_(origin_, type_),
quota_status_(quota::kQuotaStatusUnknown),
usage_(-1) {
@ -212,8 +212,8 @@ class ObfuscatedFileUtilTest : public testing::Test {
void GetUsageFromQuotaManager() {
quota_manager_->GetUsageAndQuota(
origin(), test_helper_.storage_type(),
callback_factory_.NewCallback(
&ObfuscatedFileUtilTest::OnGetUsage));
base::Bind(&ObfuscatedFileUtilTest::OnGetUsage,
weak_factory_.GetWeakPtr()));
MessageLoop::current()->RunAllPending();
EXPECT_EQ(quota::kQuotaStatusOk, quota_status_);
}
@ -483,8 +483,7 @@ class ObfuscatedFileUtilTest : public testing::Test {
scoped_refptr<FileSystemContext> file_system_context_;
GURL origin_;
fileapi::FileSystemType type_;
base::ScopedCallbackFactory<ObfuscatedFileUtilTest>
callback_factory_;
base::WeakPtrFactory<ObfuscatedFileUtilTest> weak_factory_;
FileSystemTestOriginHelper test_helper_;
quota::QuotaStatusCode quota_status_;
int64 usage_;

24
webkit/quota/mock_quota_manager.cc

@ -23,7 +23,7 @@ class MockQuotaManager::GetModifiedSinceTask : public QuotaThreadTask {
GetModifiedSinceTask(MockQuotaManager* manager,
const std::set<GURL>& origins,
StorageType type,
GetOriginsCallback* callback)
const GetOriginsCallback& callback)
: QuotaThreadTask(manager, manager->io_thread_),
origins_(origins),
type_(type),
@ -33,17 +33,17 @@ class MockQuotaManager::GetModifiedSinceTask : public QuotaThreadTask {
virtual void RunOnTargetThread() OVERRIDE {}
virtual void Completed() 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:
std::set<GURL> origins_;
StorageType type_;
scoped_ptr<GetOriginsCallback> callback_;
GetOriginsCallback callback_;
DISALLOW_COPY_AND_ASSIGN(GetModifiedSinceTask);
};
@ -51,7 +51,7 @@ class MockQuotaManager::GetModifiedSinceTask : public QuotaThreadTask {
class MockQuotaManager::DeleteOriginDataTask : public QuotaThreadTask {
public:
DeleteOriginDataTask(MockQuotaManager* manager,
StatusCallback* callback)
const StatusCallback& callback)
: QuotaThreadTask(manager, manager->io_thread_),
callback_(callback) {}
@ -59,15 +59,15 @@ class MockQuotaManager::DeleteOriginDataTask : public QuotaThreadTask {
virtual void RunOnTargetThread() OVERRIDE {}
virtual void Completed() OVERRIDE {
callback_->Run(quota::kQuotaStatusOk);
callback_.Run(quota::kQuotaStatusOk);
}
virtual void Aborted() OVERRIDE {
callback_->Run(quota::kQuotaErrorAbort);
callback_.Run(quota::kQuotaErrorAbort);
}
private:
scoped_ptr<StatusCallback> callback_;
StatusCallback callback_;
DISALLOW_COPY_AND_ASSIGN(DeleteOriginDataTask);
};
@ -110,8 +110,10 @@ bool MockQuotaManager::OriginHasData(const GURL& origin,
return false;
}
void MockQuotaManager::GetOriginsModifiedSince(StorageType type,
base::Time modified_since, GetOriginsCallback* callback) {
void MockQuotaManager::GetOriginsModifiedSince(
StorageType type,
base::Time modified_since,
const GetOriginsCallback& callback) {
std::set<GURL> origins_to_return;
for (std::vector<OriginInfo>::const_iterator current = origins_.begin();
current != origins_.end();
@ -124,7 +126,7 @@ void MockQuotaManager::GetOriginsModifiedSince(StorageType type,
}
void MockQuotaManager::DeleteOriginData(const GURL& origin, StorageType type,
StatusCallback* callback) {
const StatusCallback& callback) {
for (std::vector<OriginInfo>::iterator current = origins_.begin();
current != origins_.end();
++current) {

12
webkit/quota/mock_quota_manager.h

@ -59,15 +59,17 @@ class MockQuotaManager : public QuotaManager {
// Overrides QuotaManager's implementation with a canned implementation that
// allows clients to set up the origin database that should be queried. This
// method will only search through the origins added explicitly via AddOrigin.
virtual void GetOriginsModifiedSince(StorageType type,
base::Time modified_since,
GetOriginsCallback* callback) OVERRIDE;
virtual void GetOriginsModifiedSince(
StorageType type,
base::Time modified_since,
const GetOriginsCallback& callback) OVERRIDE;
// Removes an origin from the canned list of origins, but doesn't touch
// anything on disk.
virtual void DeleteOriginData(const GURL& origin,
StorageType type,
StatusCallback* callback) OVERRIDE;
const StatusCallback& callback) OVERRIDE;
private:
class GetModifiedSinceTask;
class DeleteOriginDataTask;
@ -80,4 +82,4 @@ class MockQuotaManager : public QuotaManager {
} // namespace quota
#endif // WEBKIT_QUOTA_MOCK_QUOTA_MANAGER_H_
#endif // WEBKIT_QUOTA_MOCK_QUOTA_MANAGER_H_

20
webkit/quota/mock_quota_manager_unittest.cc

@ -5,8 +5,8 @@
#include <set>
#include "base/bind.h"
#include "base/file_util.h"
#include "base/memory/scoped_callback_factory.h"
#include "base/memory/scoped_ptr.h"
#include "base/message_loop.h"
#include "base/message_loop_proxy.h"
@ -29,7 +29,7 @@ const GURL kOrigin3(kTestOrigin3);
class MockQuotaManagerTest : public testing::Test {
public:
MockQuotaManagerTest()
: callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
: weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
deletion_callback_count_(0) {
}
@ -51,9 +51,10 @@ class MockQuotaManagerTest : public testing::Test {
}
void GetModifiedOrigins(StorageType type, base::Time since) {
manager_->GetOriginsModifiedSince(type, since,
callback_factory_.NewCallback(
&MockQuotaManagerTest::GotModifiedOrigins));
manager_->GetOriginsModifiedSince(
type, since,
base::Bind(&MockQuotaManagerTest::GotModifiedOrigins,
weak_factory_.GetWeakPtr()));
}
void GotModifiedOrigins(const std::set<GURL>& origins, StorageType type) {
@ -62,9 +63,10 @@ class MockQuotaManagerTest : public testing::Test {
}
void DeleteOriginData(const GURL& origin, StorageType type) {
manager_->DeleteOriginData(origin, type,
callback_factory_.NewCallback(
&MockQuotaManagerTest::DeletedOriginData));
manager_->DeleteOriginData(
origin, type,
base::Bind(&MockQuotaManagerTest::DeletedOriginData,
weak_factory_.GetWeakPtr()));
}
void DeletedOriginData(QuotaStatusCode status) {
@ -90,7 +92,7 @@ class MockQuotaManagerTest : public testing::Test {
private:
ScopedTempDir data_dir_;
base::ScopedCallbackFactory<MockQuotaManagerTest> callback_factory_;
base::WeakPtrFactory<MockQuotaManagerTest> weak_factory_;
scoped_refptr<MockQuotaManager> manager_;
scoped_refptr<MockSpecialStoragePolicy> policy_;

50
webkit/quota/mock_storage_client.cc

@ -55,13 +55,7 @@ MockStorageClient::MockStorageClient(
}
}
MockStorageClient::~MockStorageClient() {
STLDeleteContainerPointers(usage_callbacks_.begin(), usage_callbacks_.end());
STLDeleteContainerPointers(
origins_callbacks_.begin(), origins_callbacks_.end());
STLDeleteContainerPointers(
deletion_callbacks_.begin(), deletion_callbacks_.end());
}
MockStorageClient::~MockStorageClient() {}
void MockStorageClient::AddOriginAndNotify(
const GURL& origin_url, StorageType type, int64 size) {
@ -113,8 +107,7 @@ void MockStorageClient::OnQuotaManagerDestroyed() {
void MockStorageClient::GetOriginUsage(const GURL& origin_url,
StorageType type,
GetUsageCallback* callback) {
usage_callbacks_.insert(callback);
const GetUsageCallback& callback) {
base::MessageLoopProxy::current()->PostTask(
FROM_HERE, runnable_factory_.NewRunnableMethod(
&MockStorageClient::RunGetOriginUsage,
@ -122,8 +115,7 @@ void MockStorageClient::GetOriginUsage(const GURL& origin_url,
}
void MockStorageClient::GetOriginsForType(
StorageType type, GetOriginsCallback* callback) {
origins_callbacks_.insert(callback);
StorageType type, const GetOriginsCallback& callback) {
base::MessageLoopProxy::current()->PostTask(
FROM_HERE, runnable_factory_.NewRunnableMethod(
&MockStorageClient::RunGetOriginsForType,
@ -132,8 +124,7 @@ void MockStorageClient::GetOriginsForType(
void MockStorageClient::GetOriginsForHost(
StorageType type, const std::string& host,
GetOriginsCallback* callback) {
origins_callbacks_.insert(callback);
const GetOriginsCallback& callback) {
base::MessageLoopProxy::current()->PostTask(
FROM_HERE, runnable_factory_.NewRunnableMethod(
&MockStorageClient::RunGetOriginsForHost,
@ -142,8 +133,7 @@ void MockStorageClient::GetOriginsForHost(
void MockStorageClient::DeleteOriginData(
const GURL& origin, StorageType type,
DeletionCallback* callback) {
deletion_callbacks_.insert(callback);
const DeletionCallback& callback) {
base::MessageLoopProxy::current()->PostTask(
FROM_HERE, runnable_factory_.NewRunnableMethod(
&MockStorageClient::RunDeleteOriginData,
@ -151,35 +141,30 @@ void MockStorageClient::DeleteOriginData(
}
void MockStorageClient::RunGetOriginUsage(
const GURL& origin_url, StorageType type, GetUsageCallback* callback_ptr) {
usage_callbacks_.erase(callback_ptr);
scoped_ptr<GetUsageCallback> callback(callback_ptr);
const GURL& origin_url, StorageType type,
const GetUsageCallback& callback) {
OriginDataMap::iterator find = origin_data_.find(make_pair(origin_url, type));
if (find == origin_data_.end()) {
callback->Run(0);
callback.Run(0);
} else {
callback->Run(find->second);
callback.Run(find->second);
}
}
void MockStorageClient::RunGetOriginsForType(
StorageType type, GetOriginsCallback* callback_ptr) {
scoped_ptr<GetOriginsCallback> callback(callback_ptr);
origins_callbacks_.erase(callback_ptr);
StorageType type, const GetOriginsCallback& callback) {
std::set<GURL> origins;
for (OriginDataMap::iterator iter = origin_data_.begin();
iter != origin_data_.end(); ++iter) {
if (type == iter->first.second)
origins.insert(iter->first.first);
}
callback->Run(origins, type);
callback.Run(origins, type);
}
void MockStorageClient::RunGetOriginsForHost(
StorageType type, const std::string& host,
GetOriginsCallback* callback_ptr) {
scoped_ptr<GetOriginsCallback> callback(callback_ptr);
origins_callbacks_.erase(callback_ptr);
const GetOriginsCallback& callback) {
std::set<GURL> origins;
for (OriginDataMap::iterator iter = origin_data_.begin();
iter != origin_data_.end(); ++iter) {
@ -187,19 +172,17 @@ void MockStorageClient::RunGetOriginsForHost(
if (type == iter->first.second && host == host_or_spec)
origins.insert(iter->first.first);
}
callback->Run(origins, type);
callback.Run(origins, type);
}
void MockStorageClient::RunDeleteOriginData(
const GURL& origin_url,
StorageType type,
DeletionCallback* callback_ptr) {
scoped_ptr<DeletionCallback> callback(callback_ptr);
const DeletionCallback& callback) {
ErrorOriginSet::iterator itr_error =
error_origins_.find(make_pair(origin_url, type));
if (itr_error != error_origins_.end()) {
deletion_callbacks_.erase(callback_ptr);
callback->Run(kQuotaErrorInvalidModification);
callback.Run(kQuotaErrorInvalidModification);
return;
}
@ -212,8 +195,7 @@ void MockStorageClient::RunDeleteOriginData(
origin_data_.erase(itr);
}
deletion_callbacks_.erase(callback_ptr);
callback->Run(kQuotaStatusOk);
callback.Run(kQuotaStatusOk);
}
} // namespace quota

21
webkit/quota/mock_storage_client.h

@ -8,6 +8,7 @@
#include <map>
#include <set>
#include <string>
#include <utility>
#include "base/compiler_specific.h"
#include "base/task.h"
@ -48,27 +49,27 @@ class MockStorageClient : public QuotaClient {
virtual void OnQuotaManagerDestroyed() OVERRIDE;
virtual void GetOriginUsage(const GURL& origin_url,
StorageType type,
GetUsageCallback* callback) OVERRIDE;
const GetUsageCallback& callback) OVERRIDE;
virtual void GetOriginsForType(StorageType type,
GetOriginsCallback* callback) OVERRIDE;
const GetOriginsCallback& callback) OVERRIDE;
virtual void GetOriginsForHost(StorageType type, const std::string& host,
GetOriginsCallback* callback) OVERRIDE;
const GetOriginsCallback& callback) OVERRIDE;
virtual void DeleteOriginData(const GURL& origin,
StorageType type,
DeletionCallback* callback) OVERRIDE;
const DeletionCallback& callback) OVERRIDE;
private:
void RunGetOriginUsage(const GURL& origin_url,
StorageType type,
GetUsageCallback* callback);
const GetUsageCallback& callback);
void RunGetOriginsForType(StorageType type,
GetOriginsCallback* callback);
const GetOriginsCallback& callback);
void RunGetOriginsForHost(StorageType type,
const std::string& host,
GetOriginsCallback* callback);
const GetOriginsCallback& callback);
void RunDeleteOriginData(const GURL& origin_url,
StorageType type,
DeletionCallback* callback);
const DeletionCallback& callback);
scoped_refptr<QuotaManagerProxy> quota_manager_proxy_;
const ID id_;
@ -78,10 +79,6 @@ class MockStorageClient : public QuotaClient {
typedef std::set<std::pair<GURL, StorageType> > ErrorOriginSet;
ErrorOriginSet error_origins_;
std::set<GetUsageCallback*> usage_callbacks_;
std::set<GetOriginsCallback*> origins_callbacks_;
std::set<DeletionCallback*> deletion_callbacks_;
int mock_time_counter_;
ScopedRunnableMethodFactory<MockStorageClient> runnable_factory_;

16
webkit/quota/quota_client.h

@ -9,7 +9,7 @@
#include <set>
#include <string>
#include "base/callback_old.h"
#include "base/callback.h"
#include "base/time.h"
#include "googleurl/src/gurl.h"
#include "webkit/quota/quota_types.h"
@ -22,10 +22,10 @@ namespace quota {
// All the methods are assumed to be called on the IO thread in the browser.
class QuotaClient {
public:
typedef Callback1<int64>::Type GetUsageCallback;
typedef Callback2<const std::set<GURL>&, StorageType>::Type
typedef base::Callback<void(int64)> GetUsageCallback; // NOLINT
typedef base::Callback<void(const std::set<GURL>&, StorageType)>
GetOriginsCallback;
typedef Callback1<QuotaStatusCode>::Type DeletionCallback;
typedef base::Callback<void(QuotaStatusCode)> DeletionCallback;
virtual ~QuotaClient() {}
@ -48,23 +48,23 @@ class QuotaClient {
// |origin_url| and |type|.
virtual void GetOriginUsage(const GURL& origin_url,
StorageType type,
GetUsageCallback* callback) = 0;
const GetUsageCallback& callback) = 0;
// Called by the QuotaManager.
// Returns a list of origins that has data in the |type| storage.
virtual void GetOriginsForType(StorageType type,
GetOriginsCallback* callback) = 0;
const GetOriginsCallback& callback) = 0;
// Called by the QuotaManager.
// Returns a list of origins that match the |host|.
virtual void GetOriginsForHost(StorageType type,
const std::string& host,
GetOriginsCallback* callback) = 0;
const GetOriginsCallback& callback) = 0;
// Called by the QuotaManager.
virtual void DeleteOriginData(const GURL& origin,
StorageType type,
DeletionCallback* callback) = 0;
const DeletionCallback& callback) = 0;
};
// TODO(dmikurube): Replace it to std::vector for efficiency.

253
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 {
@ -76,24 +73,22 @@ const int QuotaManager::kEvictionIntervalInMilliSeconds =
// Callback translators.
void CallGetUsageAndQuotaCallback(
QuotaManager::GetUsageAndQuotaCallback* callback,
const QuotaManager::GetUsageAndQuotaCallback& callback,
bool unlimited,
QuotaStatusCode status,
const QuotaAndUsage& quota_and_usage) {
int64 usage =
unlimited ? quota_and_usage.unlimited_usage : quota_and_usage.usage;
int64 quota = unlimited ? kint64max : quota_and_usage.quota;
callback->Run(status, usage, quota);
delete callback;
callback.Run(status, usage, quota);
}
void CallQuotaCallback(
QuotaCallback* callback,
const QuotaCallback& callback,
StorageType type,
QuotaStatusCode status,
const QuotaAndUsage& quota_and_usage) {
callback->Run(status, type, quota_and_usage.quota);
delete callback;
callback.Run(status, type, quota_and_usage.quota);
}
// This class is for posting GetUsage/GetQuota tasks, gathering
@ -171,7 +166,7 @@ class QuotaManager::UsageAndQuotaDispatcherTask : public QuotaTask {
available_space_(-1),
quota_status_(kQuotaStatusUnknown),
waiting_callbacks_(1),
ALLOW_THIS_IN_INITIALIZER_LIST(callback_factory_(this)) {}
weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {}
virtual ~UsageAndQuotaDispatcherTask() {}
@ -246,27 +241,28 @@ 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());
}
HostQuotaCallback* NewWaitableHostQuotaCallback() {
HostQuotaCallback NewWaitableHostQuotaCallback() {
++waiting_callbacks_;
return callback_factory_.NewCallback(
&UsageAndQuotaDispatcherTask::DidGetHostQuota);
return base::Bind(&UsageAndQuotaDispatcherTask::DidGetHostQuota,
weak_factory_.GetWeakPtr());
}
AvailableSpaceCallback* NewWaitableAvailableSpaceCallback() {
AvailableSpaceCallback NewWaitableAvailableSpaceCallback() {
++waiting_callbacks_;
return callback_factory_.NewCallback(
&UsageAndQuotaDispatcherTask::DidGetAvailableSpace);
return base::Bind(&UsageAndQuotaDispatcherTask::DidGetAvailableSpace,
weak_factory_.GetWeakPtr());
}
private:
void CheckCompleted() {
if (--waiting_callbacks_ <= 0) {
@ -292,7 +288,7 @@ class QuotaManager::UsageAndQuotaDispatcherTask : public QuotaTask {
QuotaStatusCode quota_status_;
CallbackList callbacks_;
int waiting_callbacks_;
ScopedCallbackFactory<UsageAndQuotaDispatcherTask> callback_factory_;
base::WeakPtrFactory<UsageAndQuotaDispatcherTask> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(UsageAndQuotaDispatcherTask);
};
@ -304,28 +300,30 @@ class QuotaManager::GetUsageInfoTask : public QuotaTask {
public:
GetUsageInfoTask(
QuotaManager* manager,
GetUsageInfoCallback* callback)
const GetUsageInfoCallback& callback)
: QuotaTask(manager),
callback_(callback),
ALLOW_THIS_IN_INITIALIZER_LIST(callback_factory_(this)) {
weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
}
protected:
virtual void Run() OVERRIDE {
remaining_trackers_ = 2;
// This will populate cached hosts and usage info.
manager()->GetUsageTracker(kStorageTypeTemporary)->GetGlobalUsage(
callback_factory_.NewCallback(&GetUsageInfoTask::DidGetGlobalUsage));
base::Bind(&GetUsageInfoTask::DidGetGlobalUsage,
weak_factory_.GetWeakPtr()));
manager()->GetUsageTracker(kStorageTypePersistent)->GetGlobalUsage(
callback_factory_.NewCallback(&GetUsageInfoTask::DidGetGlobalUsage));
base::Bind(&GetUsageInfoTask::DidGetGlobalUsage,
weak_factory_.GetWeakPtr()));
}
virtual void Completed() OVERRIDE {
callback_->Run(entries_);
callback_.Run(entries_);
DeleteSoon();
}
virtual void Aborted() OVERRIDE {
callback_->Run(UsageInfoEntries());
callback_.Run(UsageInfoEntries());
DeleteSoon();
}
@ -350,9 +348,9 @@ class QuotaManager::GetUsageInfoTask : public QuotaTask {
return static_cast<QuotaManager*>(observer());
}
scoped_ptr<GetUsageInfoCallback> callback_;
GetUsageInfoCallback callback_;
UsageInfoEntries entries_;
base::ScopedCallbackFactory<GetUsageInfoTask> callback_factory_;
base::WeakPtrFactory<GetUsageInfoTask> weak_factory_;
int remaining_trackers_;
DISALLOW_COPY_AND_ASSIGN(GetUsageInfoTask);
@ -464,14 +462,14 @@ class QuotaManager::OriginDataDeleter : public QuotaTask {
OriginDataDeleter(QuotaManager* manager,
const GURL& origin,
StorageType type,
StatusCallback* callback)
const StatusCallback& callback)
: QuotaTask(manager),
origin_(origin),
type_(type),
error_count_(0),
remaining_clients_(-1),
callback_(callback),
ALLOW_THIS_IN_INITIALIZER_LIST(callback_factory_(this)) {}
weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {}
protected:
virtual void Run() OVERRIDE {
@ -479,23 +477,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();
}
@ -517,9 +517,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);
};
@ -592,7 +592,7 @@ class QuotaManager::UpdateTemporaryQuotaOverrideTask
UpdateTemporaryQuotaOverrideTask(
QuotaManager* manager,
int64 new_quota,
QuotaCallback* callback)
const QuotaCallback& callback)
: DatabaseTaskBase(manager),
new_quota_(new_quota),
callback_(callback) {}
@ -618,14 +618,14 @@ class QuotaManager::UpdateTemporaryQuotaOverrideTask
private:
void CallCallback(QuotaStatusCode status, StorageType type, int64 quota) {
if (callback_.get()) {
callback_->Run(status, type, quota);
callback_.reset();
if (!callback_.is_null()) {
callback_.Run(status, type, quota);
callback_.Reset();
}
}
int64 new_quota_;
scoped_ptr<QuotaCallback> callback_;
QuotaCallback callback_;
};
class QuotaManager::GetPersistentHostQuotaTask
@ -634,7 +634,7 @@ class QuotaManager::GetPersistentHostQuotaTask
GetPersistentHostQuotaTask(
QuotaManager* manager,
const std::string& host,
HostQuotaCallback* callback)
const HostQuotaCallback& callback)
: DatabaseTaskBase(manager),
host_(host),
quota_(-1),
@ -646,13 +646,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
@ -662,7 +662,7 @@ class QuotaManager::UpdatePersistentHostQuotaTask
QuotaManager* manager,
const std::string& host,
int new_quota,
HostQuotaCallback* callback)
const HostQuotaCallback& callback)
: DatabaseTaskBase(manager),
host_(host),
new_quota_(new_quota),
@ -678,18 +678,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
@ -804,7 +804,7 @@ class QuotaManager::AvailableSpaceQueryTask : public QuotaThreadTask {
public:
AvailableSpaceQueryTask(
QuotaManager* manager,
AvailableSpaceCallback* callback)
const AvailableSpaceCallback& callback)
: QuotaThreadTask(manager, manager->db_thread_),
profile_path_(manager->profile_path_),
space_(-1),
@ -818,17 +818,17 @@ class QuotaManager::AvailableSpaceQueryTask : public QuotaThreadTask {
}
virtual void Aborted() OVERRIDE {
callback_.reset();
callback_.Reset();
}
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
@ -893,7 +893,7 @@ class QuotaManager::GetModifiedSinceTask
QuotaManager* manager,
StorageType type,
base::Time modified_since,
GetOriginsCallback* callback)
GetOriginsCallback callback)
: DatabaseTaskBase(manager),
type_(type),
modified_since_(modified_since),
@ -908,18 +908,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
@ -934,7 +934,7 @@ class QuotaManager::DumpQuotaTableTask
public:
DumpQuotaTableTask(
QuotaManager* manager,
Callback* callback)
const Callback& callback)
: DatabaseTaskBase(manager),
callback_(callback) {
}
@ -947,11 +947,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:
@ -960,7 +960,7 @@ class QuotaManager::DumpQuotaTableTask
return true;
}
scoped_ptr<Callback> callback_;
Callback callback_;
TableEntries entries_;
};
@ -976,7 +976,7 @@ class QuotaManager::DumpOriginInfoTableTask
public:
DumpOriginInfoTableTask(
QuotaManager* manager,
Callback* callback)
const Callback& callback)
: DatabaseTaskBase(manager),
callback_(callback) {
}
@ -989,11 +989,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:
@ -1002,7 +1002,7 @@ class QuotaManager::DumpOriginInfoTableTask
return true;
}
scoped_ptr<Callback> callback_;
Callback callback_;
TableEntries entries_;
};
@ -1025,8 +1025,7 @@ QuotaManager::QuotaManager(bool is_incognito,
temporary_quota_override_(-1),
desired_available_space_(-1),
special_storage_policy_(special_storage_policy),
ALLOW_THIS_IN_INITIALIZER_LIST(callback_factory_(this)),
ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
}
QuotaManager::~QuotaManager() {
@ -1038,7 +1037,7 @@ QuotaManager::~QuotaManager() {
db_thread_->DeleteSoon(FROM_HERE, database_.release());
}
void QuotaManager::GetUsageInfo(GetUsageInfoCallback* callback) {
void QuotaManager::GetUsageInfo(const GetUsageInfoCallback& callback) {
LazyInitialize();
GetUsageInfoTask* get_usage_info = new GetUsageInfoTask(this, callback);
get_usage_info->Start();
@ -1046,26 +1045,24 @@ void QuotaManager::GetUsageInfo(GetUsageInfoCallback* callback) {
void QuotaManager::GetUsageAndQuota(
const GURL& origin, StorageType type,
GetUsageAndQuotaCallback* callback) {
const GetUsageAndQuotaCallback& callback) {
GetUsageAndQuotaInternal(origin, type, false /* global */,
base::Bind(&CallGetUsageAndQuotaCallback,
callback, IsStorageUnlimited(origin)));
}
void QuotaManager::GetAvailableSpace(AvailableSpaceCallback* callback) {
void QuotaManager::GetAvailableSpace(const AvailableSpaceCallback& callback) {
if (is_incognito_) {
callback->Run(kQuotaStatusOk, kIncognitoDefaultTemporaryQuota);
delete callback;
callback.Run(kQuotaStatusOk, kIncognitoDefaultTemporaryQuota);
return;
}
make_scoped_refptr(new AvailableSpaceQueryTask(this, callback))->Start();
}
void QuotaManager::GetTemporaryGlobalQuota(QuotaCallback* callback) {
void QuotaManager::GetTemporaryGlobalQuota(const QuotaCallback& callback) {
if (temporary_quota_override_ > 0) {
callback->Run(kQuotaStatusOk, kStorageTypeTemporary,
temporary_quota_override_);
delete callback;
callback.Run(kQuotaStatusOk, kStorageTypeTemporary,
temporary_quota_override_);
return;
}
GetUsageAndQuotaInternal(
@ -1074,80 +1071,77 @@ void QuotaManager::GetTemporaryGlobalQuota(QuotaCallback* callback) {
}
void QuotaManager::SetTemporaryGlobalOverrideQuota(
int64 new_quota, QuotaCallback* callback_ptr) {
scoped_ptr<QuotaCallback> callback(callback_ptr);
int64 new_quota, const QuotaCallback& callback) {
LazyInitialize();
if (new_quota < 0) {
if (callback.get())
callback->Run(kQuotaErrorInvalidModification,
kStorageTypeTemporary, -1);
if (!callback.is_null())
callback.Run(kQuotaErrorInvalidModification,
kStorageTypeTemporary, -1);
return;
}
if (db_disabled_) {
if (callback.get())
callback->Run(kQuotaErrorInvalidAccess,
kStorageTypeTemporary, -1);
if (callback.is_null())
callback.Run(kQuotaErrorInvalidAccess,
kStorageTypeTemporary, -1);
return;
}
make_scoped_refptr(new UpdateTemporaryQuotaOverrideTask(
this, new_quota, callback.release()))->Start();
this, new_quota, callback))->Start();
}
void QuotaManager::GetPersistentHostQuota(const std::string& host,
HostQuotaCallback* callback_ptr) {
scoped_ptr<HostQuotaCallback> callback(callback_ptr);
const 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);
const 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) {
void QuotaManager::GetGlobalUsage(StorageType type,
const GlobalUsageCallback& callback) {
LazyInitialize();
GetUsageTracker(type)->GetGlobalUsage(callback);
}
void QuotaManager::GetHostUsage(const std::string& host, StorageType type,
HostUsageCallback* callback) {
void QuotaManager::GetHostUsage(const std::string& host,
StorageType type,
const HostUsageCallback& callback) {
LazyInitialize();
GetUsageTracker(type)->GetHostUsage(host, callback);
}
@ -1165,10 +1159,9 @@ void QuotaManager::GetStatistics(
}
}
void QuotaManager::GetOriginsModifiedSince(
StorageType type,
base::Time modified_since,
GetOriginsCallback* callback) {
void QuotaManager::GetOriginsModifiedSince(StorageType type,
base::Time modified_since,
const GetOriginsCallback& callback) {
LazyInitialize();
make_scoped_refptr(new GetModifiedSinceTask(
this, type, modified_since, callback))->Start();
@ -1228,12 +1221,11 @@ void QuotaManager::NotifyOriginNoLongerInUse(const GURL& origin) {
}
void QuotaManager::DeleteOriginData(
const GURL& origin, StorageType type, StatusCallback* callback) {
const GURL& origin, StorageType type, const StatusCallback& callback) {
LazyInitialize();
if (origin.is_empty() || clients_.empty()) {
callback->Run(kQuotaStatusOk);
delete callback;
callback.Run(kQuotaStatusOk);
return;
}
@ -1363,12 +1355,12 @@ void QuotaManager::GetUsageAndQuotaInternal(
}
}
void QuotaManager::DumpQuotaTable(DumpQuotaTableCallback* callback) {
void QuotaManager::DumpQuotaTable(const DumpQuotaTableCallback& callback) {
make_scoped_refptr(new DumpQuotaTableTask(this, callback))->Start();
}
void QuotaManager::DumpOriginInfoTable(
DumpOriginInfoTableCallback* callback) {
const DumpOriginInfoTableCallback& callback) {
make_scoped_refptr(new DumpOriginInfoTableTask(this, callback))->Start();
}
@ -1402,8 +1394,7 @@ void QuotaManager::GetLRUOrigin(
task->Start();
}
void QuotaManager::DidOriginDataEvicted(
QuotaStatusCode status) {
void QuotaManager::DidOriginDataEvicted(QuotaStatusCode status) {
DCHECK(io_thread_->BelongsToCurrentThread());
// We only try evict origins that are not in use, so basically
@ -1413,23 +1404,24 @@ 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) {
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.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::GetUsageAndQuotaForEviction(
@ -1451,11 +1443,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(
@ -1523,8 +1517,9 @@ void QuotaManager::DidRunInitializeTask() {
// Kick the first GetTemporaryGlobalQuota. This internally fetches (and
// caches) the usage of all origins and checks the available disk space.
GetTemporaryGlobalQuota(callback_factory_.NewCallback(
&QuotaManager::DidGetInitialTemporaryGlobalQuota));
GetTemporaryGlobalQuota(
base::Bind(&QuotaManager::DidGetInitialTemporaryGlobalQuota,
weak_factory_.GetWeakPtr()));
}
void QuotaManager::DidGetInitialTemporaryGlobalQuota(

49
webkit/quota/quota_manager.h

@ -11,13 +11,14 @@
#include <map>
#include <set>
#include <string>
#include <utility>
#include <vector>
#include "base/basictypes.h"
#include "base/callback.h"
#include "base/file_path.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_callback_factory.h"
#include "base/memory/weak_ptr.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
#include "webkit/quota/quota_database.h"
@ -73,7 +74,7 @@ class QuotaEvictionHandler {
virtual void EvictOriginData(
const GURL& origin,
StorageType type,
EvictOriginDataCallback* callback) = 0;
const EvictOriginDataCallback& callback) = 0;
virtual void GetUsageAndQuotaForEviction(
const GetUsageAndQuotaForEvictionCallback& callback) = 0;
@ -97,9 +98,10 @@ class QuotaManager : public QuotaTaskObserver,
public base::RefCountedThreadSafe<
QuotaManager, QuotaManagerDeleter> {
public:
typedef Callback3<QuotaStatusCode,
int64 /* usage */,
int64 /* quota */>::Type GetUsageAndQuotaCallback;
typedef base::Callback<void(QuotaStatusCode,
int64 /* usage */,
int64 /* quota */)>
GetUsageAndQuotaCallback;
QuotaManager(bool is_incognito,
const FilePath& profile_path,
@ -113,14 +115,14 @@ class QuotaManager : public QuotaTaskObserver,
QuotaManagerProxy* proxy() { return proxy_.get(); }
// Called by clients or webapps. Returns usage per host.
void GetUsageInfo(GetUsageInfoCallback* callback);
void GetUsageInfo(const GetUsageInfoCallback& callback);
// Called by clients or webapps.
// This method is declared as virtual to allow test code to override it.
// note: returns host usage and quota
virtual void GetUsageAndQuota(const GURL& origin,
StorageType type,
GetUsageAndQuotaCallback* callback);
const GetUsageAndQuotaCallback& callback);
// Called by clients via proxy.
// Client storage should call this method when storage is accessed.
@ -149,24 +151,24 @@ class QuotaManager : public QuotaTaskObserver,
// Called by UI.
virtual void DeleteOriginData(const GURL& origin,
StorageType type,
StatusCallback* callback);
const StatusCallback& callback);
// Called by UI and internal modules.
void GetAvailableSpace(AvailableSpaceCallback* callback);
void GetTemporaryGlobalQuota(QuotaCallback* callback);
void GetAvailableSpace(const AvailableSpaceCallback& callback);
void GetTemporaryGlobalQuota(const QuotaCallback& callback);
// Ok to call with NULL callback.
void SetTemporaryGlobalOverrideQuota(int64 new_quota,
QuotaCallback* callback);
const QuotaCallback& callback);
void GetPersistentHostQuota(const std::string& host,
HostQuotaCallback* callback);
const HostQuotaCallback& callback);
void SetPersistentHostQuota(const std::string& host,
int64 new_quota,
HostQuotaCallback* callback);
void GetGlobalUsage(StorageType type, GlobalUsageCallback* callback);
const HostQuotaCallback& callback);
void GetGlobalUsage(StorageType type, const GlobalUsageCallback& callback);
void GetHostUsage(const std::string& host, StorageType type,
HostUsageCallback* callback);
const HostUsageCallback& callback);
void GetStatistics(std::map<std::string, std::string>* statistics);
@ -177,7 +179,7 @@ class QuotaManager : public QuotaTaskObserver,
virtual void GetOriginsModifiedSince(StorageType type,
base::Time modified_since,
GetOriginsCallback* callback);
const GetOriginsCallback& callback);
bool ResetUsageTracker(StorageType type);
@ -221,8 +223,9 @@ class QuotaManager : public QuotaTaskObserver,
typedef std::vector<QuotaTableEntry> QuotaTableEntries;
typedef std::vector<OriginInfoTableEntry> OriginInfoTableEntries;
typedef Callback1<const QuotaTableEntries&>::Type DumpQuotaTableCallback;
typedef Callback1<const OriginInfoTableEntries&>::Type
typedef base::Callback<void(const QuotaTableEntries&)>
DumpQuotaTableCallback;
typedef base::Callback<void(const OriginInfoTableEntries&)>
DumpOriginInfoTableCallback;
struct EvictionContext {
@ -230,7 +233,8 @@ class QuotaManager : public QuotaTaskObserver,
virtual ~EvictionContext() {}
GURL evicted_origin;
StorageType evicted_type;
scoped_ptr<EvictOriginDataCallback> evict_origin_data_callback;
EvictOriginDataCallback evict_origin_data_callback;
};
typedef std::pair<std::string, StorageType> HostAndType;
@ -285,8 +289,8 @@ class QuotaManager : public QuotaTaskObserver,
bool global,
const UsageAndQuotaDispatcherCallback& callback);
void DumpQuotaTable(DumpQuotaTableCallback* callback);
void DumpOriginInfoTable(DumpOriginInfoTableCallback* callback);
void DumpQuotaTable(const DumpQuotaTableCallback& callback);
void DumpOriginInfoTable(const DumpOriginInfoTableCallback& callback);
// Methods for eviction logic.
void StartEviction();
@ -315,7 +319,7 @@ class QuotaManager : public QuotaTaskObserver,
virtual void EvictOriginData(
const GURL& origin,
StorageType type,
EvictOriginDataCallback* callback) OVERRIDE;
const EvictOriginDataCallback& callback) OVERRIDE;
virtual void GetUsageAndQuotaForEviction(
const GetUsageAndQuotaForEvictionCallback& callback) OVERRIDE;
@ -364,7 +368,6 @@ class QuotaManager : public QuotaTaskObserver,
scoped_refptr<SpecialStoragePolicy> special_storage_policy_;
base::ScopedCallbackFactory<QuotaManager> callback_factory_;
base::WeakPtrFactory<QuotaManager> weak_factory_;
base::RepeatingTimer<QuotaManager> histogram_timer_;

100
webkit/quota/quota_manager_unittest.cc

@ -8,7 +8,6 @@
#include "base/bind.h"
#include "base/file_util.h"
#include "base/memory/scoped_callback_factory.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/message_loop.h"
@ -40,8 +39,7 @@ class QuotaManagerTest : public testing::Test {
public:
QuotaManagerTest()
: callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
: weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
mock_time_counter_(0) {
}
@ -78,25 +76,27 @@ class QuotaManagerTest : public testing::Test {
void GetUsageInfo() {
usage_info_.clear();
quota_manager_->GetUsageInfo(callback_factory_.NewCallback(
&QuotaManagerTest::DidGetUsageInfo));
quota_manager_->GetUsageInfo(
base::Bind(&QuotaManagerTest::DidGetUsageInfo,
weak_factory_.GetWeakPtr()));
}
void GetUsageAndQuota(const GURL& origin, StorageType type) {
quota_status_ = kQuotaStatusUnknown;
usage_ = -1;
quota_ = -1;
quota_manager_->GetUsageAndQuota(origin, type,
callback_factory_.NewCallback(
&QuotaManagerTest::DidGetUsageAndQuota));
quota_manager_->GetUsageAndQuota(
origin, type,
base::Bind(&QuotaManagerTest::DidGetUsageAndQuota,
weak_factory_.GetWeakPtr()));
}
void GetTemporaryGlobalQuota() {
quota_status_ = kQuotaStatusUnknown;
quota_ = -1;
quota_manager_->GetTemporaryGlobalQuota(
callback_factory_.NewCallback(
&QuotaManagerTest::DidGetQuota));
base::Bind(&QuotaManagerTest::DidGetQuota,
weak_factory_.GetWeakPtr()));
}
void SetTemporaryGlobalQuota(int64 new_quota) {
@ -104,8 +104,8 @@ class QuotaManagerTest : public testing::Test {
quota_ = -1;
quota_manager_->SetTemporaryGlobalOverrideQuota(
new_quota,
callback_factory_.NewCallback(
&QuotaManagerTest::DidGetQuota));
base::Bind(&QuotaManagerTest::DidGetQuota,
weak_factory_.GetWeakPtr()));
}
void GetPersistentHostQuota(const std::string& host) {
@ -113,9 +113,10 @@ class QuotaManagerTest : public testing::Test {
host_.clear();
type_ = kStorageTypeUnknown;
quota_ = -1;
quota_manager_->GetPersistentHostQuota(host,
callback_factory_.NewCallback(
&QuotaManagerTest::DidGetHostQuota));
quota_manager_->GetPersistentHostQuota(
host,
base::Bind(&QuotaManagerTest::DidGetHostQuota,
weak_factory_.GetWeakPtr()));
}
void SetPersistentHostQuota(const std::string& host, int64 new_quota) {
@ -123,33 +124,37 @@ class QuotaManagerTest : public testing::Test {
host_.clear();
type_ = kStorageTypeUnknown;
quota_ = -1;
quota_manager_->SetPersistentHostQuota(host, new_quota,
callback_factory_.NewCallback(
&QuotaManagerTest::DidGetHostQuota));
quota_manager_->SetPersistentHostQuota(
host, new_quota,
base::Bind(&QuotaManagerTest::DidGetHostQuota,
weak_factory_.GetWeakPtr()));
}
void GetGlobalUsage(StorageType type) {
type_ = kStorageTypeUnknown;
usage_ = -1;
unlimited_usage_ = -1;
quota_manager_->GetGlobalUsage(type,
callback_factory_.NewCallback(
&QuotaManagerTest::DidGetGlobalUsage));
quota_manager_->GetGlobalUsage(
type,
base::Bind(&QuotaManagerTest::DidGetGlobalUsage,
weak_factory_.GetWeakPtr()));
}
void GetHostUsage(const std::string& host, StorageType type) {
host_.clear();
type_ = kStorageTypeUnknown;
usage_ = -1;
quota_manager_->GetHostUsage(host, type,
callback_factory_.NewCallback(
&QuotaManagerTest::DidGetHostUsage));
quota_manager_->GetHostUsage(
host, type,
base::Bind(&QuotaManagerTest::DidGetHostUsage,
weak_factory_.GetWeakPtr()));
}
void RunAdditionalUsageAndQuotaTask(const GURL& origin, StorageType type) {
quota_manager_->GetUsageAndQuota(origin, type,
callback_factory_.NewCallback(
&QuotaManagerTest::DidGetUsageAndQuotaAdditional));
quota_manager_->GetUsageAndQuota(
origin, type,
base::Bind(&QuotaManagerTest::DidGetUsageAndQuotaAdditional,
weak_factory_.GetWeakPtr()));
}
void DeleteClientOriginData(QuotaClient* client,
@ -157,33 +162,36 @@ class QuotaManagerTest : public testing::Test {
StorageType type) {
DCHECK(client);
quota_status_ = kQuotaStatusUnknown;
client->DeleteOriginData(origin, type,
callback_factory_.NewCallback(
&QuotaManagerTest::StatusCallback));
client->DeleteOriginData(
origin, type,
base::Bind(&QuotaManagerTest::StatusCallback,
weak_factory_.GetWeakPtr()));
}
void EvictOriginData(const GURL& origin,
StorageType type) {
quota_status_ = kQuotaStatusUnknown;
quota_manager_->EvictOriginData(origin, type,
callback_factory_.NewCallback(
&QuotaManagerTest::StatusCallback));
quota_manager_->EvictOriginData(
origin, type,
base::Bind(&QuotaManagerTest::StatusCallback,
weak_factory_.GetWeakPtr()));
}
void DeleteOriginData(const GURL& origin,
StorageType type) {
quota_status_ = kQuotaStatusUnknown;
quota_manager_->DeleteOriginData(origin, type,
callback_factory_.NewCallback(
&QuotaManagerTest::StatusCallback));
quota_manager_->DeleteOriginData(
origin, type,
base::Bind(&QuotaManagerTest::StatusCallback,
weak_factory_.GetWeakPtr()));
}
void GetAvailableSpace() {
quota_status_ = kQuotaStatusUnknown;
available_space_ = -1;
quota_manager_->GetAvailableSpace(
callback_factory_.NewCallback(
&QuotaManagerTest::DidGetAvailableSpace));
base::Bind(&QuotaManagerTest::DidGetAvailableSpace,
weak_factory_.GetWeakPtr()));
}
void GetUsageAndQuotaForEviction() {
@ -234,23 +242,24 @@ class QuotaManagerTest : public testing::Test {
void GetOriginsModifiedSince(StorageType type, base::Time modified_since) {
modified_origins_.clear();
modified_origins_type_ = kStorageTypeUnknown;
quota_manager_->GetOriginsModifiedSince(type, modified_since,
callback_factory_.NewCallback(
&QuotaManagerTest::DidGetModifiedOrigins));
quota_manager_->GetOriginsModifiedSince(
type, modified_since,
base::Bind(&QuotaManagerTest::DidGetModifiedOrigins,
weak_factory_.GetWeakPtr()));
}
void DumpQuotaTable() {
quota_entries_.clear();
quota_manager_->DumpQuotaTable(
callback_factory_.NewCallback(
&QuotaManagerTest::DidDumpQuotaTable));
base::Bind(&QuotaManagerTest::DidDumpQuotaTable,
weak_factory_.GetWeakPtr()));
}
void DumpOriginInfoTable() {
origin_info_entries_.clear();
quota_manager_->DumpOriginInfoTable(
callback_factory_.NewCallback(
&QuotaManagerTest::DidDumpOriginInfoTable));
base::Bind(&QuotaManagerTest::DidDumpOriginInfoTable,
weak_factory_.GetWeakPtr()));
}
void DidGetUsageInfo(const UsageInfoEntries& entries) {
@ -376,7 +385,6 @@ class QuotaManagerTest : public testing::Test {
}
ScopedTempDir data_dir_;
base::ScopedCallbackFactory<QuotaManagerTest> callback_factory_;
base::WeakPtrFactory<QuotaManagerTest> weak_factory_;
scoped_refptr<QuotaManager> quota_manager_;

8
webkit/quota/quota_temporary_storage_evictor.cc

@ -4,6 +4,8 @@
#include "webkit/quota/quota_temporary_storage_evictor.h"
#include <algorithm>
#include "base/bind.h"
#include "base/metrics/histogram.h"
#include "googleurl/src/gurl.h"
@ -41,7 +43,6 @@ QuotaTemporaryStorageEvictor::QuotaTemporaryStorageEvictor(
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);
}
@ -218,8 +219,9 @@ void QuotaTemporaryStorageEvictor::OnGotLRUOrigin(const GURL& origin) {
}
quota_eviction_handler_->EvictOriginData(origin, kStorageTypeTemporary,
callback_factory_.NewCallback(
&QuotaTemporaryStorageEvictor::OnEvictionComplete));
base::Bind(
&QuotaTemporaryStorageEvictor::OnEvictionComplete,
weak_factory_.GetWeakPtr()));
}
void QuotaTemporaryStorageEvictor::OnEvictionComplete(

3
webkit/quota/quota_temporary_storage_evictor.h

@ -9,7 +9,6 @@
#include <map>
#include <string>
#include "base/memory/scoped_callback_factory.h"
#include "base/memory/weak_ptr.h"
#include "base/threading/non_thread_safe.h"
#include "base/timer.h"
@ -132,8 +131,6 @@ class QuotaTemporaryStorageEvictor : public base::NonThreadSafe {
base::OneShotTimer<QuotaTemporaryStorageEvictor> eviction_timer_;
base::RepeatingTimer<QuotaTemporaryStorageEvictor> histogram_timer_;
base::ScopedCallbackFactory<QuotaTemporaryStorageEvictor> callback_factory_;
base::WeakPtrFactory<QuotaTemporaryStorageEvictor> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(QuotaTemporaryStorageEvictor);

14
webkit/quota/quota_temporary_storage_evictor_unittest.cc

@ -2,16 +2,16 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "testing/gtest/include/gtest/gtest.h"
#include <list>
#include <map>
#include <utility>
#include "base/bind.h"
#include "base/memory/scoped_ptr.h"
#include "base/message_loop.h"
#include "base/message_loop_proxy.h"
#include "base/task.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "webkit/quota/mock_storage_client.h"
#include "webkit/quota/quota_manager.h"
#include "webkit/quota/quota_temporary_storage_evictor.h"
@ -24,7 +24,7 @@ namespace {
class MockQuotaEvictionHandler : public quota::QuotaEvictionHandler {
public:
MockQuotaEvictionHandler(QuotaTemporaryStorageEvictorTest *test)
explicit MockQuotaEvictionHandler(QuotaTemporaryStorageEvictorTest *test)
: quota_(0),
unlimited_usage_(0),
available_space_(0),
@ -35,17 +35,15 @@ class MockQuotaEvictionHandler : public quota::QuotaEvictionHandler {
virtual void EvictOriginData(
const GURL& origin,
StorageType type,
EvictOriginDataCallback* callback) OVERRIDE {
const EvictOriginDataCallback& callback) OVERRIDE {
if (error_on_evict_origin_data_) {
callback->Run(quota::kQuotaErrorInvalidModification);
delete callback;
callback.Run(quota::kQuotaErrorInvalidModification);
return;
}
int64 origin_usage = EnsureOriginRemoved(origin);
if (origin_usage >= 0)
available_space_ += origin_usage;
callback->Run(quota::kQuotaStatusOk);
delete callback;
callback.Run(quota::kQuotaStatusOk);
}
virtual void GetUsageAndQuotaForEviction(

68
webkit/quota/quota_types.h

@ -10,10 +10,10 @@
#include <map>
#include <set>
#include <string>
#include <vector>
#include "base/basictypes.h"
#include "base/callback_old.h"
#include "base/stl_util.h"
#include "base/callback.h"
class GURL;
@ -40,23 +40,21 @@ struct UsageInfo;
typedef std::vector<UsageInfo> UsageInfoEntries;
// Common callback types that are used throughout in the quota module.
typedef Callback2<StorageType, int64>::Type UsageCallback;
typedef Callback3<StorageType, int64, int64>::Type GlobalUsageCallback;
typedef Callback3<QuotaStatusCode,
StorageType,
int64>::Type QuotaCallback;
typedef Callback3<const std::string& /* host */,
StorageType,
int64>::Type HostUsageCallback;
typedef Callback4<QuotaStatusCode,
const std::string& /* host */,
StorageType,
int64>::Type HostQuotaCallback;
typedef Callback2<QuotaStatusCode,
int64>::Type AvailableSpaceCallback;
typedef Callback1<QuotaStatusCode>::Type StatusCallback;
typedef Callback2<const std::set<GURL>&, StorageType>::Type GetOriginsCallback;
typedef Callback1<const UsageInfoEntries&>::Type GetUsageInfoCallback;
typedef base::Callback<void(StorageType, int64)> UsageCallback;
typedef base::Callback<void(StorageType, int64, int64)> GlobalUsageCallback;
typedef base::Callback<void(QuotaStatusCode, StorageType, int64)>
QuotaCallback;
typedef base::Callback<void(const std::string&, StorageType, int64)>
HostUsageCallback;
typedef base::Callback<void(QuotaStatusCode,
const std::string&,
StorageType,
int64)> HostQuotaCallback;
typedef base::Callback<void(QuotaStatusCode, int64)> AvailableSpaceCallback;
typedef base::Callback<void(QuotaStatusCode)> StatusCallback;
typedef base::Callback<void(const std::set<GURL>&, StorageType)>
GetOriginsCallback;
typedef base::Callback<void(const UsageInfoEntries&)> GetUsageInfoCallback;
// Simple template wrapper for a callback queue.
template <typename CallbackType>
@ -65,12 +63,10 @@ class CallbackQueueBase {
typedef typename std::deque<CallbackType> Queue;
typedef typename Queue::iterator iterator;
virtual ~CallbackQueueBase() {
STLDeleteContainerPointers(callbacks_.begin(), callbacks_.end());
}
virtual ~CallbackQueueBase() {}
// Returns true if the given |callback| is the first one added to the queue.
bool Add(CallbackType callback) {
bool Add(const CallbackType& callback) {
callbacks_.push_back(callback);
return (callbacks_.size() == 1);
}
@ -92,8 +88,7 @@ class CallbackQueue1 : public CallbackQueueBase<CallbackType1> {
// Note: template-derived class needs 'this->' to access its base class.
for (typename Queue::iterator iter = this->callbacks_.begin();
iter != this->callbacks_.end(); ++iter) {
(*iter)->Run(arg);
delete *iter;
iter->Run(arg);
}
this->callbacks_.clear();
}
@ -107,8 +102,7 @@ class CallbackQueue2 : public CallbackQueueBase<CallbackType2> {
void Run(A1 arg1, A2 arg2) {
for (typename Queue::iterator iter = this->callbacks_.begin();
iter != this->callbacks_.end(); ++iter) {
(*iter)->Run(arg1, arg2);
delete *iter;
iter->Run(arg1, arg2);
}
this->callbacks_.clear();
}
@ -122,8 +116,7 @@ class CallbackQueue3 : public CallbackQueueBase<CallbackType3> {
void Run(A1 arg1, A2 arg2, A3 arg3) {
for (typename Queue::iterator iter = this->callbacks_.begin();
iter != this->callbacks_.end(); ++iter) {
(*iter)->Run(arg1, arg2, arg3);
delete *iter;
iter->Run(arg1, arg2, arg3);
}
this->callbacks_.clear();
}
@ -138,18 +131,17 @@ class CallbackQueue4 : public CallbackQueueBase<CallbackType4> {
void Run(A1 arg1, A2 arg2, A3 arg3, A4 arg4) {
for (typename Queue::iterator iter = this->callbacks_.begin();
iter != this->callbacks_.end(); ++iter) {
(*iter)->Run(arg1, arg2, arg3, arg4);
delete *iter;
iter->Run(arg1, arg2, arg3, arg4);
}
this->callbacks_.clear();
}
};
typedef CallbackQueue2<UsageCallback*,
typedef CallbackQueue2<UsageCallback,
StorageType, int64> UsageCallbackQueue;
typedef CallbackQueue3<GlobalUsageCallback*,
typedef CallbackQueue3<GlobalUsageCallback,
StorageType, int64, int64> GlobalUsageCallbackQueue;
typedef CallbackQueue3<QuotaCallback*,
typedef CallbackQueue3<QuotaCallback,
QuotaStatusCode,
StorageType, int64> QuotaCallbackQueue;
@ -159,7 +151,7 @@ class CallbackQueueMapBase {
typedef std::map<KEY, CallbackQueueType> CallbackMap;
typedef typename CallbackMap::iterator iterator;
bool Add(const KEY& key, CallbackType callback) {
bool Add(const KEY& key, const CallbackType& callback) {
return callback_map_[key].Add(callback);
}
@ -276,11 +268,11 @@ class CallbackQueueMap4
}
};
typedef CallbackQueueMap1<UsageCallback*, GURL, int64> OriginUsageCallbackMap;
typedef CallbackQueueMap3<HostUsageCallback*, std::string,
typedef CallbackQueueMap1<UsageCallback, GURL, int64> OriginUsageCallbackMap;
typedef CallbackQueueMap3<HostUsageCallback, std::string,
const std::string&,
StorageType, int64> HostUsageCallbackMap;
typedef CallbackQueueMap4<HostQuotaCallback*, std::string,
typedef CallbackQueueMap4<HostQuotaCallback, std::string,
QuotaStatusCode,
const std::string&,
StorageType, int64> HostQuotaCallbackMap;

60
webkit/quota/usage_tracker.cc

@ -8,7 +8,9 @@
#include <deque>
#include <set>
#include <string>
#include <vector>
#include "base/bind.h"
#include "base/message_loop_proxy.h"
#include "base/stl_util.h"
#include "net/base/net_util.h"
@ -31,7 +33,7 @@ class ClientUsageTracker::GatherUsageTaskBase : public QuotaTask {
: QuotaTask(tracker),
client_(client),
tracker_(tracker),
callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
DCHECK(tracker_);
DCHECK(client_);
client_tracker_ = tracker_->GetClientTracker(client_->id());
@ -75,7 +77,8 @@ class ClientUsageTracker::GatherUsageTaskBase : public QuotaTask {
client_->GetOriginUsage(
*iter,
tracker_->type(),
callback_factory_.NewCallback(&GatherUsageTaskBase::DidGetUsage));
base::Bind(&GatherUsageTaskBase::DidGetUsage,
weak_factory_.GetWeakPtr()));
}
protected:
@ -121,7 +124,7 @@ class ClientUsageTracker::GatherUsageTaskBase : public QuotaTask {
ClientUsageTracker* client_tracker_;
std::deque<GURL> pending_origins_;
std::map<GURL, int64> origin_usage_map_;
base::ScopedCallbackFactory<GatherUsageTaskBase> callback_factory_;
base::WeakPtrFactory<GatherUsageTaskBase> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(GatherUsageTaskBase);
};
@ -136,7 +139,7 @@ class ClientUsageTracker::GatherGlobalUsageTask
QuotaClient* client)
: GatherUsageTaskBase(tracker, client),
client_(client),
callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
DCHECK(tracker);
DCHECK(client);
}
@ -145,8 +148,8 @@ class ClientUsageTracker::GatherGlobalUsageTask
protected:
virtual void Run() OVERRIDE {
client_->GetOriginsForType(tracker()->type(),
callback_factory_.NewCallback(
&GatherUsageTaskBase::GetUsageForOrigins));
base::Bind(&GatherUsageTaskBase::GetUsageForOrigins,
weak_factory_.GetWeakPtr()));
}
virtual void Completed() OVERRIDE {
@ -155,7 +158,7 @@ class ClientUsageTracker::GatherGlobalUsageTask
private:
QuotaClient* client_;
base::ScopedCallbackFactory<GatherUsageTaskBase> callback_factory_;
base::WeakPtrFactory<GatherUsageTaskBase> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(GatherGlobalUsageTask);
};
@ -172,7 +175,7 @@ class ClientUsageTracker::GatherHostUsageTask
: GatherUsageTaskBase(tracker, client),
client_(client),
host_(host),
callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
DCHECK(client_);
}
virtual ~GatherHostUsageTask() {}
@ -180,8 +183,8 @@ class ClientUsageTracker::GatherHostUsageTask
protected:
virtual void Run() OVERRIDE {
client_->GetOriginsForHost(tracker()->type(), host_,
callback_factory_.NewCallback(
&GatherUsageTaskBase::GetUsageForOrigins));
base::Bind(&GatherUsageTaskBase::GetUsageForOrigins,
weak_factory_.GetWeakPtr()));
}
virtual void Completed() OVERRIDE {
@ -191,7 +194,7 @@ class ClientUsageTracker::GatherHostUsageTask
private:
QuotaClient* client_;
std::string host_;
base::ScopedCallbackFactory<GatherUsageTaskBase> callback_factory_;
base::WeakPtrFactory<GatherUsageTaskBase> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(GatherHostUsageTask);
};
@ -201,7 +204,7 @@ class ClientUsageTracker::GatherHostUsageTask
UsageTracker::UsageTracker(const QuotaClientList& clients, StorageType type,
SpecialStoragePolicy* special_storage_policy)
: type_(type),
callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
for (QuotaClientList::const_iterator iter = clients.begin();
iter != clients.end();
++iter) {
@ -222,11 +225,10 @@ ClientUsageTracker* UsageTracker::GetClientTracker(QuotaClient::ID client_id) {
return NULL;
}
void UsageTracker::GetGlobalUsage(GlobalUsageCallback* callback) {
void UsageTracker::GetGlobalUsage(const GlobalUsageCallback& callback) {
if (client_tracker_map_.size() == 0) {
// No clients registered.
callback->Run(type_, 0, 0);
delete callback;
callback.Run(type_, 0, 0);
return;
}
if (global_usage_callbacks_.Add(callback)) {
@ -238,18 +240,18 @@ void UsageTracker::GetGlobalUsage(GlobalUsageCallback* callback) {
for (ClientTrackerMap::iterator iter = client_tracker_map_.begin();
iter != client_tracker_map_.end();
++iter) {
iter->second->GetGlobalUsage(callback_factory_.NewCallback(
&UsageTracker::DidGetClientGlobalUsage));
iter->second->GetGlobalUsage(
base::Bind(&UsageTracker::DidGetClientGlobalUsage,
weak_factory_.GetWeakPtr()));
}
}
}
void UsageTracker::GetHostUsage(
const std::string& host, HostUsageCallback* callback) {
const std::string& host, const HostUsageCallback& callback) {
if (client_tracker_map_.size() == 0) {
// No clients registered.
callback->Run(host, type_, 0);
delete callback;
callback.Run(host, type_, 0);
return;
}
if (host_usage_callbacks_.Add(host, callback)) {
@ -259,8 +261,9 @@ void UsageTracker::GetHostUsage(
for (ClientTrackerMap::iterator iter = client_tracker_map_.begin();
iter != client_tracker_map_.end();
++iter) {
iter->second->GetHostUsage(host, callback_factory_.NewCallback(
&UsageTracker::DidGetClientHostUsage));
iter->second->GetHostUsage(host,
base::Bind(&UsageTracker::DidGetClientHostUsage,
weak_factory_.GetWeakPtr()));
}
}
}
@ -357,10 +360,9 @@ ClientUsageTracker::~ClientUsageTracker() {
special_storage_policy_->RemoveObserver(this);
}
void ClientUsageTracker::GetGlobalUsage(GlobalUsageCallback* callback) {
void ClientUsageTracker::GetGlobalUsage(const GlobalUsageCallback& callback) {
if (global_usage_retrieved_) {
callback->Run(type_, global_usage_, GetCachedGlobalUnlimitedUsage());
delete callback;
callback.Run(type_, global_usage_, GetCachedGlobalUnlimitedUsage());
return;
}
DCHECK(!global_usage_callback_.HasCallbacks());
@ -370,12 +372,11 @@ void ClientUsageTracker::GetGlobalUsage(GlobalUsageCallback* callback) {
}
void ClientUsageTracker::GetHostUsage(
const std::string& host, HostUsageCallback* callback) {
const std::string& host, const HostUsageCallback& callback) {
HostSet::const_iterator found = cached_hosts_.find(host);
if (found != cached_hosts_.end()) {
// TODO(kinuko): Drop host_usage_map_ cache periodically.
callback->Run(host, type_, GetCachedHostUsage(host));
delete callback;
callback.Run(host, type_, GetCachedHostUsage(host));
return;
}
if (!host_usage_callbacks_.Add(host, callback) || global_usage_task_)
@ -400,7 +401,8 @@ void ClientUsageTracker::UpdateUsageCache(
// We don't know about this host yet, so populate our cache for it.
GetHostUsage(host,
NewCallback(this, &ClientUsageTracker::NoopHostUsageCallback));
base::Bind(&ClientUsageTracker::NoopHostUsageCallback,
base::Unretained(this)));
}
void ClientUsageTracker::GetCachedHostsUsage(

11
webkit/quota/usage_tracker.h

@ -13,7 +13,6 @@
#include "base/basictypes.h"
#include "base/callback.h"
#include "base/memory/scoped_callback_factory.h"
#include "base/memory/scoped_ptr.h"
#include "base/threading/non_thread_safe.h"
#include "googleurl/src/gurl.h"
@ -38,8 +37,8 @@ class UsageTracker : public QuotaTaskObserver {
StorageType type() const { return type_; }
ClientUsageTracker* GetClientTracker(QuotaClient::ID client_id);
void GetGlobalUsage(GlobalUsageCallback* callback);
void GetHostUsage(const std::string& host, HostUsageCallback* callback);
void GetGlobalUsage(const GlobalUsageCallback& callback);
void GetHostUsage(const std::string& host, const HostUsageCallback& callback);
void UpdateUsageCache(QuotaClient::ID client_id,
const GURL& origin,
int64 delta);
@ -75,7 +74,7 @@ class UsageTracker : public QuotaTaskObserver {
GlobalUsageCallbackQueue global_usage_callbacks_;
HostUsageCallbackMap host_usage_callbacks_;
base::ScopedCallbackFactory<UsageTracker> callback_factory_;
base::WeakPtrFactory<UsageTracker> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(UsageTracker);
};
@ -90,8 +89,8 @@ class ClientUsageTracker : public SpecialStoragePolicy::Observer,
SpecialStoragePolicy* special_storage_policy);
virtual ~ClientUsageTracker();
void GetGlobalUsage(GlobalUsageCallback* callback);
void GetHostUsage(const std::string& host, HostUsageCallback* callback);
void GetGlobalUsage(const GlobalUsageCallback& callback);
void GetHostUsage(const std::string& host, const HostUsageCallback& callback);
void UpdateUsageCache(const GURL& origin, int64 delta);
void GetCachedHostsUsage(std::map<std::string, int64>* host_usage) const;
void GetCachedOrigins(std::set<GURL>* origins) const;