diff options
25 files changed, 270 insertions, 265 deletions
diff --git a/net/spdy/spdy_session.h b/net/spdy/spdy_session.h index 139b6ef..72fd8c2 100644 --- a/net/spdy/spdy_session.h +++ b/net/spdy/spdy_session.h @@ -257,7 +257,9 @@ class NET_EXPORT SpdySession : public base::RefCounted<SpdySession>, priority(priority), spdy_stream(spdy_stream), stream_net_log(&stream_net_log), - callback(callback) {} + callback(callback) { + } + ~PendingCreateStream(); const GURL* url; diff --git a/webkit/appcache/appcache_disk_cache.cc b/webkit/appcache/appcache_disk_cache.cc index 4c7d794..7cdc4ae 100644 --- a/webkit/appcache/appcache_disk_cache.cc +++ b/webkit/appcache/appcache_disk_cache.cc @@ -59,30 +59,28 @@ class AppCacheDiskCache::EntryImpl : public Entry { class AppCacheDiskCache::ActiveCall { public: explicit ActiveCall(AppCacheDiskCache* owner) - : entry_(NULL), callback_(NULL), owner_(owner), entry_ptr_(NULL), - ALLOW_THIS_IN_INITIALIZER_LIST( - async_completion_(this, &ActiveCall::OnAsyncCompletion)) { + : entry_(NULL), + owner_(owner), + entry_ptr_(NULL) { } int CreateEntry(int64 key, Entry** entry, - net::OldCompletionCallback* callback) { + const net::CompletionCallback& callback) { int rv = owner_->disk_cache()->CreateEntry( base::Int64ToString(key), &entry_ptr_, - base::Bind(&ActiveCall::OnAsyncCompletion, - base::Unretained(this))); + base::Bind(&ActiveCall::OnAsyncCompletion, base::Unretained(this))); return HandleImmediateReturnValue(rv, entry, callback); } int OpenEntry(int64 key, Entry** entry, - net::OldCompletionCallback* callback) { + const net::CompletionCallback& callback) { int rv = owner_->disk_cache()->OpenEntry( base::Int64ToString(key), &entry_ptr_, - base::Bind(&ActiveCall::OnAsyncCompletion, - base::Unretained(this))); + base::Bind(&ActiveCall::OnAsyncCompletion, base::Unretained(this))); return HandleImmediateReturnValue(rv, entry, callback); } - int DoomEntry(int64 key, net::OldCompletionCallback* callback) { + int DoomEntry(int64 key, const net::CompletionCallback& callback) { int rv = owner_->disk_cache()->DoomEntry( base::Int64ToString(key), base::Bind(&ActiveCall::OnAsyncCompletion, base::Unretained(this))); @@ -91,7 +89,7 @@ class AppCacheDiskCache::ActiveCall { private: int HandleImmediateReturnValue(int rv, Entry** entry, - net::OldCompletionCallback* callback) { + const net::CompletionCallback& callback) { if (rv == net::ERR_IO_PENDING) { // OnAsyncCompletion will be called later. callback_ = callback; @@ -109,20 +107,19 @@ class AppCacheDiskCache::ActiveCall { owner_->RemoveActiveCall(this); if (rv == net::OK && entry_) *entry_ = new EntryImpl(entry_ptr_); - callback_->Run(rv); - callback_ = NULL; + callback_.Run(rv); + callback_.Reset(); delete this; } Entry** entry_; - net::OldCompletionCallback* callback_; + net::CompletionCallback callback_; AppCacheDiskCache* owner_; disk_cache::Entry* entry_ptr_; - net::OldCompletionCallbackImpl<ActiveCall> async_completion_; }; AppCacheDiskCache::AppCacheDiskCache() - : is_disabled_(false), init_callback_(NULL) { + : is_disabled_(false) { } AppCacheDiskCache::~AppCacheDiskCache() { @@ -137,13 +134,14 @@ AppCacheDiskCache::~AppCacheDiskCache() { int AppCacheDiskCache::InitWithDiskBackend( const FilePath& disk_cache_directory, int disk_cache_size, bool force, - base::MessageLoopProxy* cache_thread, net::OldCompletionCallback* callback) { + base::MessageLoopProxy* cache_thread, + const net::CompletionCallback& callback) { return Init(net::APP_CACHE, disk_cache_directory, disk_cache_size, force, cache_thread, callback); } int AppCacheDiskCache::InitWithMemBackend( - int mem_cache_size, net::OldCompletionCallback* callback) { + int mem_cache_size, const net::CompletionCallback& callback) { return Init(net::MEMORY_CACHE, FilePath(), mem_cache_size, false, NULL, callback); } @@ -162,8 +160,9 @@ void AppCacheDiskCache::Disable() { } int AppCacheDiskCache::CreateEntry(int64 key, Entry** entry, - net::OldCompletionCallback* callback) { - DCHECK(entry && callback); + const net::CompletionCallback& callback) { + DCHECK(entry); + DCHECK(!callback.is_null()); if (is_disabled_) return net::ERR_ABORTED; @@ -179,8 +178,9 @@ int AppCacheDiskCache::CreateEntry(int64 key, Entry** entry, } int AppCacheDiskCache::OpenEntry(int64 key, Entry** entry, - net::OldCompletionCallback* callback) { - DCHECK(entry && callback); + const net::CompletionCallback& callback) { + DCHECK(entry); + DCHECK(!callback.is_null()); if (is_disabled_) return net::ERR_ABORTED; @@ -196,8 +196,8 @@ int AppCacheDiskCache::OpenEntry(int64 key, Entry** entry, } int AppCacheDiskCache::DoomEntry(int64 key, - net::OldCompletionCallback* callback) { - DCHECK(callback); + const net::CompletionCallback& callback) { + DCHECK(!callback.is_null()); if (is_disabled_) return net::ERR_ABORTED; @@ -212,11 +212,13 @@ int AppCacheDiskCache::DoomEntry(int64 key, return (new ActiveCall(this))->DoomEntry(key, callback); } +AppCacheDiskCache::PendingCall::~PendingCall() {} + int AppCacheDiskCache::Init(net::CacheType cache_type, const FilePath& cache_directory, int cache_size, bool force, base::MessageLoopProxy* cache_thread, - net::OldCompletionCallback* callback) { + const net::CompletionCallback& callback) { DCHECK(!is_initializing() && !disk_cache_.get()); is_disabled_ = false; create_backend_callback_ = new CreateBackendCallback( @@ -241,9 +243,9 @@ void AppCacheDiskCache::OnCreateBackendComplete(int rv) { create_backend_callback_ = NULL; // Invoke our clients callback function. - if (init_callback_) { - init_callback_->Run(rv); - init_callback_ = NULL; + if (!init_callback_.is_null()) { + init_callback_.Run(rv); + init_callback_.Reset(); } // Service pending calls that were queued up while we were initailizating. @@ -265,7 +267,7 @@ void AppCacheDiskCache::OnCreateBackendComplete(int rv) { break; } if (rv != net::ERR_IO_PENDING) - iter->callback->Run(rv); + iter->callback.Run(rv); } pending_calls_.clear(); } diff --git a/webkit/appcache/appcache_disk_cache.h b/webkit/appcache/appcache_disk_cache.h index f5259c2..069127c 100644 --- a/webkit/appcache/appcache_disk_cache.h +++ b/webkit/appcache/appcache_disk_cache.h @@ -27,22 +27,22 @@ class APPCACHE_EXPORT AppCacheDiskCache int InitWithDiskBackend(const FilePath& disk_cache_directory, int disk_cache_size, bool force, base::MessageLoopProxy* cache_thread, - net::OldCompletionCallback* callback); + const net::CompletionCallback& callback); // Initializes the object to use memory only storage. // This is used for Chrome's incognito browsing. int InitWithMemBackend(int disk_cache_size, - net::OldCompletionCallback* callback); + const net::CompletionCallback& callback); void Disable(); bool is_disabled() const { return is_disabled_; } virtual int CreateEntry(int64 key, Entry** entry, - net::OldCompletionCallback* callback) OVERRIDE; + const net::CompletionCallback& callback) OVERRIDE; virtual int OpenEntry(int64 key, Entry** entry, - net::OldCompletionCallback* callback) OVERRIDE; + const net::CompletionCallback& callback) OVERRIDE; virtual int DoomEntry(int64 key, - net::OldCompletionCallback* callback) OVERRIDE; + const net::CompletionCallback& callback) OVERRIDE; private: class EntryImpl; @@ -76,13 +76,23 @@ class APPCACHE_EXPORT AppCacheDiskCache PendingCallType call_type; int64 key; Entry** entry; - net::OldCompletionCallback* callback; + net::CompletionCallback callback; PendingCall() - : call_type(CREATE), key(0), entry(NULL), callback(NULL) {} + : call_type(CREATE), + key(0), + entry(NULL) { + } + PendingCall(PendingCallType call_type, int64 key, - Entry** entry, net::OldCompletionCallback* callback) - : call_type(call_type), key(key), entry(entry), callback(callback) {} + Entry** entry, const net::CompletionCallback& callback) + : call_type(call_type), + key(key), + entry(entry), + callback(callback) { + } + + ~PendingCall(); }; typedef std::vector<PendingCall> PendingCalls; @@ -95,13 +105,13 @@ class APPCACHE_EXPORT AppCacheDiskCache disk_cache::Backend* disk_cache() { return disk_cache_.get(); } int Init(net::CacheType cache_type, const FilePath& directory, int cache_size, bool force, base::MessageLoopProxy* cache_thread, - net::OldCompletionCallback* callback); + const net::CompletionCallback& callback); void OnCreateBackendComplete(int rv); void AddActiveCall(ActiveCall* call) { active_calls_.insert(call); } void RemoveActiveCall(ActiveCall* call) { active_calls_.erase(call); } bool is_disabled_; - net::OldCompletionCallback* init_callback_; + net::CompletionCallback init_callback_; scoped_refptr<CreateBackendCallback> create_backend_callback_; PendingCalls pending_calls_; ActiveCalls active_calls_; diff --git a/webkit/appcache/appcache_request_handler_unittest.cc b/webkit/appcache/appcache_request_handler_unittest.cc index edbda46..c576133 100644 --- a/webkit/appcache/appcache_request_handler_unittest.cc +++ b/webkit/appcache/appcache_request_handler_unittest.cc @@ -55,24 +55,13 @@ class AppCacheRequestHandlerTest : public testing::Test { virtual void OnContentBlocked(int host_id, const GURL& manifest_url) {} }; - // Helper class run a test on our io_thread. The io_thread - // is spun up once and reused for all tests. + // Helper callback to run a test on our io_thread. The io_thread is spun up + // once and reused for all tests. template <class Method> - class WrapperTask : public Task { - public: - WrapperTask(AppCacheRequestHandlerTest* test, Method method) - : test_(test), method_(method) { - } - - virtual void Run() { - test_->SetUpTest(); - (test_->*method_)(); - } - - private: - AppCacheRequestHandlerTest* test_; - Method method_; - }; + void MethodWrapper(Method method) { + SetUpTest(); + (this->*method)(); + } // Subclasses to simulate particular responses so test cases can // exercise fallback code paths. @@ -168,7 +157,9 @@ class AppCacheRequestHandlerTest : public testing::Test { void RunTestOnIOThread(Method method) { test_finished_event_ .reset(new base::WaitableEvent(false, false)); io_thread_->message_loop()->PostTask( - FROM_HERE, new WrapperTask<Method>(this, method)); + FROM_HERE, + base::Bind(&AppCacheRequestHandlerTest::MethodWrapper<Method>, + base::Unretained(this), method)); test_finished_event_->Wait(); } diff --git a/webkit/appcache/appcache_response.cc b/webkit/appcache/appcache_response.cc index 60be758..05fdbf6 100644 --- a/webkit/appcache/appcache_response.cc +++ b/webkit/appcache/appcache_response.cc @@ -9,6 +9,7 @@ #include "base/message_loop.h" #include "base/pickle.h" #include "base/string_util.h" +#include "net/base/completion_callback.h" #include "net/base/net_errors.h" #include "net/base/io_buffer.h" #include "webkit/appcache/appcache_service.h" @@ -74,8 +75,11 @@ HttpResponseInfoIOBuffer::~HttpResponseInfoIOBuffer() {} AppCacheResponseIO::AppCacheResponseIO( int64 response_id, int64 group_id, AppCacheDiskCacheInterface* disk_cache) - : response_id_(response_id), group_id_(group_id), disk_cache_(disk_cache), - entry_(NULL), buffer_len_(0), user_callback_(NULL), + : response_id_(response_id), + group_id_(group_id), + disk_cache_(disk_cache), + entry_(NULL), + buffer_len_(0), ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) { } @@ -95,9 +99,9 @@ void AppCacheResponseIO::InvokeUserOldCompletionCallback(int result) { // so the caller can schedule additional operations in the callback. buffer_ = NULL; info_buffer_ = NULL; - net::OldCompletionCallback* temp_user_callback = user_callback_; - user_callback_ = NULL; - temp_user_callback->Run(result); + net::CompletionCallback cb = callback_; + callback_.Reset(); + cb.Run(result); } void AppCacheResponseIO::ReadRaw(int index, int offset, @@ -143,13 +147,16 @@ AppCacheResponseReader::~AppCacheResponseReader() { } void AppCacheResponseReader::ReadInfo(HttpResponseInfoIOBuffer* info_buf, - net::OldCompletionCallback* callback) { - DCHECK(callback && !IsReadPending()); - DCHECK(info_buf && !info_buf->http_info.get()); - DCHECK(!buffer_.get() && !info_buffer_.get()); + const net::CompletionCallback& callback) { + DCHECK(!callback.is_null()); + DCHECK(!IsReadPending()); + DCHECK(info_buf); + DCHECK(!info_buf->http_info.get()); + DCHECK(!buffer_.get()); + DCHECK(!info_buffer_.get()); info_buffer_ = info_buf; - user_callback_ = callback; // cleared on completion + callback_ = callback; // cleared on completion OpenEntryIfNeededAndContinue(); } @@ -170,14 +177,17 @@ void AppCacheResponseReader::ContinueReadInfo() { } void AppCacheResponseReader::ReadData(net::IOBuffer* buf, int buf_len, - net::OldCompletionCallback* callback) { - DCHECK(callback && !IsReadPending()); - DCHECK(buf && (buf_len >= 0)); - DCHECK(!buffer_.get() && !info_buffer_.get()); + const net::CompletionCallback& callback) { + DCHECK(!callback.is_null()); + DCHECK(!IsReadPending()); + DCHECK(buf); + DCHECK(buf_len >= 0); + DCHECK(!buffer_.get()); + DCHECK(!info_buffer_.get()); buffer_ = buf; buffer_len_ = buf_len; - user_callback_ = callback; // cleared on completion + callback_ = callback; // cleared on completion OpenEntryIfNeededAndContinue(); } @@ -237,8 +247,9 @@ void AppCacheResponseReader::OpenEntryIfNeededAndContinue() { } else { open_callback_ = new EntryCallback<AppCacheResponseReader>( this, &AppCacheResponseReader::OnOpenEntryComplete); - rv = disk_cache_->OpenEntry(response_id_, &open_callback_->entry_ptr_, - open_callback_.get()); + rv = disk_cache_->OpenEntry( + response_id_, &open_callback_->entry_ptr_, + base::Bind(&net::OldCompletionCallbackAdapter, open_callback_)); } if (rv != net::ERR_IO_PENDING) @@ -276,15 +287,19 @@ AppCacheResponseWriter::~AppCacheResponseWriter() { create_callback_.release()->Cancel(); } -void AppCacheResponseWriter::WriteInfo(HttpResponseInfoIOBuffer* info_buf, - net::OldCompletionCallback* callback) { - DCHECK(callback && !IsWritePending()); - DCHECK(info_buf && info_buf->http_info.get()); - DCHECK(!buffer_.get() && !info_buffer_.get()); +void AppCacheResponseWriter::WriteInfo( + HttpResponseInfoIOBuffer* info_buf, + const net::CompletionCallback& callback) { + DCHECK(!callback.is_null()); + DCHECK(!IsWritePending()); + DCHECK(info_buf); + DCHECK(info_buf->http_info.get()); + DCHECK(!buffer_.get()); + DCHECK(!info_buffer_.get()); DCHECK(info_buf->http_info->headers); info_buffer_ = info_buf; - user_callback_ = callback; // cleared on completion + callback_ = callback; // cleared on completion CreateEntryIfNeededAndContinue(); } @@ -303,15 +318,18 @@ void AppCacheResponseWriter::ContinueWriteInfo() { WriteRaw(kResponseInfoIndex, 0, buffer_, write_amount_); } -void AppCacheResponseWriter::WriteData(net::IOBuffer* buf, int buf_len, - net::OldCompletionCallback* callback) { - DCHECK(callback && !IsWritePending()); - DCHECK(buf && (buf_len >= 0)); - DCHECK(!buffer_.get() && !info_buffer_.get()); +void AppCacheResponseWriter::WriteData( + net::IOBuffer* buf, int buf_len, const net::CompletionCallback& callback) { + DCHECK(!callback.is_null()); + DCHECK(!IsWritePending()); + DCHECK(buf); + DCHECK(buf_len >= 0); + DCHECK(!buffer_.get()); + DCHECK(!info_buffer_.get()); buffer_ = buf; write_amount_ = buf_len; - user_callback_ = callback; // cleared on completion + callback_ = callback; // cleared on completion CreateEntryIfNeededAndContinue(); } @@ -346,8 +364,9 @@ void AppCacheResponseWriter::CreateEntryIfNeededAndContinue() { creation_phase_ = INITIAL_ATTEMPT; create_callback_ = new EntryCallback<AppCacheResponseWriter>( this, &AppCacheResponseWriter::OnCreateEntryComplete); - rv = disk_cache_->CreateEntry(response_id_, &create_callback_->entry_ptr_, - create_callback_.get()); + rv = disk_cache_->CreateEntry( + response_id_, &create_callback_->entry_ptr_, + base::Bind(&net::OldCompletionCallbackAdapter, create_callback_)); } if (rv != net::ERR_IO_PENDING) OnCreateEntryComplete(rv); @@ -360,15 +379,18 @@ void AppCacheResponseWriter::OnCreateEntryComplete(int rv) { if (rv != net::OK) { // We may try to overwrite existing entries. creation_phase_ = DOOM_EXISTING; - rv = disk_cache_->DoomEntry(response_id_, create_callback_.get()); + rv = disk_cache_->DoomEntry( + response_id_, base::Bind(&net::OldCompletionCallbackAdapter, + create_callback_)); if (rv != net::ERR_IO_PENDING) OnCreateEntryComplete(rv); return; } } else if (creation_phase_ == DOOM_EXISTING) { creation_phase_ = SECOND_ATTEMPT; - rv = disk_cache_->CreateEntry(response_id_, &create_callback_->entry_ptr_, - create_callback_.get()); + rv = disk_cache_->CreateEntry( + response_id_, &create_callback_->entry_ptr_, + base::Bind(&net::OldCompletionCallbackAdapter, create_callback_)); if (rv != net::ERR_IO_PENDING) OnCreateEntryComplete(rv); return; @@ -389,4 +411,3 @@ void AppCacheResponseWriter::OnCreateEntryComplete(int rv) { } } // namespace appcache - diff --git a/webkit/appcache/appcache_response.h b/webkit/appcache/appcache_response.h index 4a538ee..b7d8a7d 100644 --- a/webkit/appcache/appcache_response.h +++ b/webkit/appcache/appcache_response.h @@ -67,7 +67,7 @@ struct APPCACHE_EXPORT HttpResponseInfoIOBuffer virtual ~HttpResponseInfoIOBuffer(); }; -// Low level storage api used by the response reader and writer. +// Low level storage API used by the response reader and writer. class APPCACHE_EXPORT AppCacheDiskCacheInterface { public: class Entry { @@ -83,10 +83,10 @@ class APPCACHE_EXPORT AppCacheDiskCacheInterface { }; virtual int CreateEntry(int64 key, Entry** entry, - net::OldCompletionCallback* callback) = 0; + const net::CompletionCallback& callback) = 0; virtual int OpenEntry(int64 key, Entry** entry, - net::OldCompletionCallback* callback) = 0; - virtual int DoomEntry(int64 key, net::OldCompletionCallback* callback) = 0; + const net::CompletionCallback& callback) = 0; + virtual int DoomEntry(int64 key, const net::CompletionCallback& callback) = 0; protected: friend class base::RefCounted<AppCacheDiskCacheInterface>; @@ -121,7 +121,7 @@ class APPCACHE_EXPORT AppCacheResponseIO { virtual void OnIOComplete(int result) = 0; - bool IsIOPending() { return user_callback_ ? true : false; } + bool IsIOPending() { return !callback_.is_null(); } void ScheduleIOOldCompletionCallback(int result); void InvokeUserOldCompletionCallback(int result); void ReadRaw(int index, int offset, net::IOBuffer* buf, int buf_len); @@ -134,7 +134,7 @@ class APPCACHE_EXPORT AppCacheResponseIO { scoped_refptr<HttpResponseInfoIOBuffer> info_buffer_; scoped_refptr<net::IOBuffer> buffer_; int buffer_len_; - net::OldCompletionCallback* user_callback_; + net::CompletionCallback callback_; base::WeakPtrFactory<AppCacheResponseIO> weak_factory_; private: @@ -160,7 +160,7 @@ class APPCACHE_EXPORT AppCacheResponseReader : public AppCacheResponseIO { // Should only be called where there is no Read operation in progress. // (virtual for testing) virtual void ReadInfo(HttpResponseInfoIOBuffer* info_buf, - net::OldCompletionCallback* callback); + const net::CompletionCallback& callback); // Reads data from storage. Always returns the result of the read // asynchronously through the 'callback'. Returns the number of bytes read @@ -171,7 +171,7 @@ class APPCACHE_EXPORT AppCacheResponseReader : public AppCacheResponseIO { // Should only be called where there is no Read operation in progress. // (virtual for testing) virtual void ReadData(net::IOBuffer* buf, int buf_len, - net::OldCompletionCallback* callback); + const net::CompletionCallback& callback); // Returns true if there is a read operation, for data or info, pending. bool IsReadPending() { return IsIOPending(); } @@ -218,7 +218,7 @@ class APPCACHE_EXPORT AppCacheResponseWriter : public AppCacheResponseIO { // required parameter. The contents of 'info_buf' are not modified. // Should only be called where there is no Write operation in progress. void WriteInfo(HttpResponseInfoIOBuffer* info_buf, - net::OldCompletionCallback* callback); + const net::CompletionCallback& callback); // Writes data to storage. Always returns the result of the write // asynchronously through the 'callback'. Returns the number of bytes written @@ -229,7 +229,7 @@ class APPCACHE_EXPORT AppCacheResponseWriter : public AppCacheResponseIO { // The contents of 'buf' are not modified. // Should only be called where there is no Write operation in progress. void WriteData(net::IOBuffer* buf, int buf_len, - net::OldCompletionCallback* callback); + const net::CompletionCallback& callback); // Returns true if there is a write pending. bool IsWritePending() { return IsIOPending(); } diff --git a/webkit/appcache/appcache_response_unittest.cc b/webkit/appcache/appcache_response_unittest.cc index 9b91712..4a4ac28 100644 --- a/webkit/appcache/appcache_response_unittest.cc +++ b/webkit/appcache/appcache_response_unittest.cc @@ -82,16 +82,7 @@ class AppCacheResponseTest : public testing::Test { io_thread_.reset(NULL); } - AppCacheResponseTest() - : ALLOW_THIS_IN_INITIALIZER_LIST(read_callback_( - this, &AppCacheResponseTest::OnReadComplete)), - ALLOW_THIS_IN_INITIALIZER_LIST(read_info_callback_( - this, &AppCacheResponseTest::OnReadInfoComplete)), - ALLOW_THIS_IN_INITIALIZER_LIST(write_callback_( - this, &AppCacheResponseTest::OnWriteComplete)), - ALLOW_THIS_IN_INITIALIZER_LIST(write_info_callback_( - this, &AppCacheResponseTest::OnWriteInfoComplete)) { - } + AppCacheResponseTest() {} template <class Method> void RunTestOnIOThread(Method method) { @@ -195,7 +186,10 @@ class AppCacheResponseTest : public testing::Test { EXPECT_FALSE(writer_->IsWritePending()); expected_write_result_ = GetHttpResponseInfoSize(head); write_info_buffer_ = new HttpResponseInfoIOBuffer(head); - writer_->WriteInfo(write_info_buffer_, &write_info_callback_); + writer_->WriteInfo( + write_info_buffer_, + base::Bind(&AppCacheResponseTest::OnWriteInfoComplete, + base::Unretained(this))); } void WriteResponseBody(scoped_refptr<IOBuffer> io_buffer, int buf_len) { @@ -203,7 +197,9 @@ class AppCacheResponseTest : public testing::Test { write_buffer_ = io_buffer; expected_write_result_ = buf_len; writer_->WriteData( - write_buffer_, buf_len, &write_callback_); + write_buffer_, buf_len, + base::Bind(&AppCacheResponseTest::OnWriteComplete, + base::Unretained(this))); } void ReadResponseBody(scoped_refptr<IOBuffer> io_buffer, int buf_len) { @@ -211,7 +207,9 @@ class AppCacheResponseTest : public testing::Test { read_buffer_ = io_buffer; expected_read_result_ = buf_len; reader_->ReadData( - read_buffer_, buf_len, &read_callback_); + read_buffer_, buf_len, + base::Bind(&AppCacheResponseTest::OnReadComplete, + base::Unretained(this))); } // AppCacheResponseReader / Writer completion callbacks @@ -321,7 +319,10 @@ class AppCacheResponseTest : public testing::Test { void ReadNonExistentInfo() { EXPECT_FALSE(reader_->IsReadPending()); read_info_buffer_ = new HttpResponseInfoIOBuffer(); - reader_->ReadInfo(read_info_buffer_, &read_info_callback_); + reader_->ReadInfo( + read_info_buffer_, + base::Bind(&AppCacheResponseTest::OnReadInfoComplete, + base::Unretained(this))); EXPECT_TRUE(reader_->IsReadPending()); expected_read_result_ = net::ERR_CACHE_MISS; } @@ -329,7 +330,10 @@ class AppCacheResponseTest : public testing::Test { void ReadNonExistentData() { EXPECT_FALSE(reader_->IsReadPending()); read_buffer_ = new IOBuffer(kBlockSize); - reader_->ReadData(read_buffer_, kBlockSize, &read_callback_); + reader_->ReadData( + read_buffer_, kBlockSize, + base::Bind(&AppCacheResponseTest::OnReadComplete, + base::Unretained(this))); EXPECT_TRUE(reader_->IsReadPending()); expected_read_result_ = net::ERR_CACHE_MISS; } @@ -506,7 +510,9 @@ class AppCacheResponseTest : public testing::Test { read_buffer_ = new IOBuffer(kBlockSize); expected_read_result_ = 0; reader_->ReadData( - read_buffer_, kBlockSize, &read_callback_); + read_buffer_, kBlockSize, + base::Bind(&AppCacheResponseTest::OnReadComplete, + base::Unretained(this))); } void ReadRange() { @@ -668,8 +674,6 @@ class AppCacheResponseTest : public testing::Test { scoped_refptr<HttpResponseInfoIOBuffer> read_info_buffer_; scoped_refptr<IOBuffer> read_buffer_; int expected_read_result_; - net::OldCompletionCallbackImpl<AppCacheResponseTest> read_callback_; - net::OldCompletionCallbackImpl<AppCacheResponseTest> read_info_callback_; bool should_delete_reader_in_completion_callback_; int reader_deletion_count_down_; bool read_callback_was_called_; @@ -679,8 +683,6 @@ class AppCacheResponseTest : public testing::Test { scoped_refptr<HttpResponseInfoIOBuffer> write_info_buffer_; scoped_refptr<IOBuffer> write_buffer_; int expected_write_result_; - net::OldCompletionCallbackImpl<AppCacheResponseTest> write_callback_; - net::OldCompletionCallbackImpl<AppCacheResponseTest> write_info_callback_; bool should_delete_writer_in_completion_callback_; int writer_deletion_count_down_; bool write_callback_was_called_; diff --git a/webkit/appcache/appcache_service.cc b/webkit/appcache/appcache_service.cc index 3d4a318..79ee7ac 100644 --- a/webkit/appcache/appcache_service.cc +++ b/webkit/appcache/appcache_service.cc @@ -5,6 +5,7 @@ #include "webkit/appcache/appcache_service.h" #include "base/bind.h" +#include "base/bind_helpers.h" #include "base/logging.h" #include "base/message_loop.h" #include "base/stl_util.h" @@ -345,11 +346,7 @@ class AppCacheService::CheckResponseHelper : AsyncHelper { kIOBufferSize(32 * 1024), expected_total_size_(0), amount_headers_read_(0), - amount_data_read_(0), - ALLOW_THIS_IN_INITIALIZER_LIST(read_info_callback_( - this, &CheckResponseHelper::OnReadInfoComplete)), - ALLOW_THIS_IN_INITIALIZER_LIST(read_data_callback_( - this, &CheckResponseHelper::OnReadDataComplete)) { + amount_data_read_(0) { } virtual void Start() { @@ -382,8 +379,6 @@ class AppCacheService::CheckResponseHelper : AsyncHelper { int64 expected_total_size_; int amount_headers_read_; int amount_data_read_; - net::OldCompletionCallbackImpl<CheckResponseHelper> read_info_callback_; - net::OldCompletionCallbackImpl<CheckResponseHelper> read_data_callback_; DISALLOW_COPY_AND_ASSIGN(CheckResponseHelper); }; @@ -418,7 +413,9 @@ void AppCacheService::CheckResponseHelper::OnGroupLoaded( response_reader_.reset(service_->storage()->CreateResponseReader( manifest_url_, group->group_id(), response_id_)); info_buffer_ = new HttpResponseInfoIOBuffer(); - response_reader_->ReadInfo(info_buffer_, &read_info_callback_); + response_reader_->ReadInfo( + info_buffer_, base::Bind(&CheckResponseHelper::OnReadInfoComplete, + base::Unretained(this))); } void AppCacheService::CheckResponseHelper::OnReadInfoComplete(int result) { @@ -433,16 +430,20 @@ void AppCacheService::CheckResponseHelper::OnReadInfoComplete(int result) { // Start reading the data. data_buffer_ = new net::IOBuffer(kIOBufferSize); - response_reader_->ReadData(data_buffer_, kIOBufferSize, - &read_data_callback_); + response_reader_->ReadData( + data_buffer_, kIOBufferSize, + base::Bind(&CheckResponseHelper::OnReadDataComplete, + base::Unretained(this))); } void AppCacheService::CheckResponseHelper::OnReadDataComplete(int result) { if (result > 0) { // Keep reading until we've read thru everything or failed to read. amount_data_read_ += result; - response_reader_->ReadData(data_buffer_, kIOBufferSize, - &read_data_callback_); + response_reader_->ReadData( + data_buffer_, kIOBufferSize, + base::Bind(&CheckResponseHelper::OnReadDataComplete, + base::Unretained(this))); return; } diff --git a/webkit/appcache/appcache_service_unittest.cc b/webkit/appcache/appcache_service_unittest.cc index 1a58964..9bc74e5 100644 --- a/webkit/appcache/appcache_service_unittest.cc +++ b/webkit/appcache/appcache_service_unittest.cc @@ -40,9 +40,9 @@ class MockResponseReader : public AppCacheResponseReader { data_(data), data_size_(data_size) { } virtual void ReadInfo(HttpResponseInfoIOBuffer* info_buf, - net::OldCompletionCallback* callback) OVERRIDE { + const net::CompletionCallback& callback) OVERRIDE { info_buffer_ = info_buf; - user_callback_ = callback; // Cleared on completion. + callback_ = callback; // Cleared on completion. int rv = info_.get() ? info_size_ : net::ERR_FAILED; info_buffer_->http_info.reset(info_.release()); @@ -50,10 +50,10 @@ class MockResponseReader : public AppCacheResponseReader { ScheduleUserCallback(rv); } virtual void ReadData(net::IOBuffer* buf, int buf_len, - net::OldCompletionCallback* callback) OVERRIDE { + const net::CompletionCallback& callback) OVERRIDE { buffer_ = buf; buffer_len_ = buf_len; - user_callback_ = callback; // Cleared on completion. + callback_ = callback; // Cleared on completion. if (!data_) { ScheduleUserCallback(net::ERR_CACHE_READ_FAILURE); diff --git a/webkit/appcache/appcache_storage.cc b/webkit/appcache/appcache_storage.cc index 7247c40..8d0b08b 100644 --- a/webkit/appcache/appcache_storage.cc +++ b/webkit/appcache/appcache_storage.cc @@ -4,6 +4,8 @@ #include "webkit/appcache/appcache_storage.h" +#include "base/bind.h" +#include "base/bind_helpers.h" #include "base/stl_util.h" #include "webkit/appcache/appcache_response.h" #include "webkit/appcache/appcache_service.h" @@ -46,9 +48,7 @@ AppCacheStorage::ResponseInfoLoadTask::ResponseInfoLoadTask( manifest_url_(manifest_url), group_id_(group_id), response_id_(response_id), - info_buffer_(new HttpResponseInfoIOBuffer), - ALLOW_THIS_IN_INITIALIZER_LIST(read_callback_( - this, &ResponseInfoLoadTask::OnReadComplete)) { + info_buffer_(new HttpResponseInfoIOBuffer) { storage_->pending_info_loads_.insert( PendingResponseInfoLoads::value_type(response_id, this)); } @@ -61,7 +61,9 @@ void AppCacheStorage::ResponseInfoLoadTask::StartIfNeeded() { return; reader_.reset( storage_->CreateResponseReader(manifest_url_, group_id_, response_id_)); - reader_->ReadInfo(info_buffer_, &read_callback_); + reader_->ReadInfo( + info_buffer_, base::Bind(&ResponseInfoLoadTask::OnReadComplete, + base::Unretained(this))); } void AppCacheStorage::ResponseInfoLoadTask::OnReadComplete(int result) { diff --git a/webkit/appcache/appcache_storage.h b/webkit/appcache/appcache_storage.h index 7aab17f..4d30ce3 100644 --- a/webkit/appcache/appcache_storage.h +++ b/webkit/appcache/appcache_storage.h @@ -254,7 +254,6 @@ class APPCACHE_EXPORT AppCacheStorage { scoped_ptr<AppCacheResponseReader> reader_; DelegateReferenceVector delegates_; scoped_refptr<HttpResponseInfoIOBuffer> info_buffer_; - net::OldCompletionCallbackImpl<ResponseInfoLoadTask> read_callback_; }; typedef std::map<int64, ResponseInfoLoadTask*> PendingResponseInfoLoads; diff --git a/webkit/appcache/appcache_storage_impl.cc b/webkit/appcache/appcache_storage_impl.cc index b374093..e2a0b26 100644 --- a/webkit/appcache/appcache_storage_impl.cc +++ b/webkit/appcache/appcache_storage_impl.cc @@ -1208,10 +1208,6 @@ AppCacheStorageImpl::AppCacheStorageImpl(AppCacheService* service) is_response_deletion_scheduled_(false), did_start_deleting_responses_(false), last_deletable_response_rowid_(0), - ALLOW_THIS_IN_INITIALIZER_LIST(doom_callback_( - this, &AppCacheStorageImpl::OnDeletedOneResponse)), - ALLOW_THIS_IN_INITIALIZER_LIST(init_callback_( - this, &AppCacheStorageImpl::OnDiskCacheInitialized)), database_(NULL), is_disabled_(false), ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) { } @@ -1596,7 +1592,9 @@ void AppCacheStorageImpl::DeleteOneResponse() { // TODO(michaeln): add group_id to DoomEntry args int64 id = deletable_response_ids_.front(); - int rv = disk_cache_->DoomEntry(id, &doom_callback_); + int rv = disk_cache_->DoomEntry( + id, base::Bind(&AppCacheStorageImpl::OnDeletedOneResponse, + base::Unretained(this))); if (rv != net::ERR_IO_PENDING) OnDeletedOneResponse(rv); } @@ -1682,11 +1680,15 @@ AppCacheDiskCache* AppCacheStorageImpl::disk_cache() { disk_cache_.reset(new AppCacheDiskCache); if (is_incognito_) { rv = disk_cache_->InitWithMemBackend( - kMaxMemDiskCacheSize, &init_callback_); + kMaxMemDiskCacheSize, + base::Bind(&AppCacheStorageImpl::OnDiskCacheInitialized, + base::Unretained(this))); } else { rv = disk_cache_->InitWithDiskBackend( cache_directory_.Append(kDiskCacheDirectoryName), - kMaxDiskCacheSize, false, cache_thread_, &init_callback_); + kMaxDiskCacheSize, false, cache_thread_, + base::Bind(&AppCacheStorageImpl::OnDiskCacheInitialized, + base::Unretained(this))); } // We should not keep this reference around. diff --git a/webkit/appcache/appcache_storage_impl.h b/webkit/appcache/appcache_storage_impl.h index f54295a..db87bbf 100644 --- a/webkit/appcache/appcache_storage_impl.h +++ b/webkit/appcache/appcache_storage_impl.h @@ -154,10 +154,6 @@ class AppCacheStorageImpl : public AppCacheStorage { bool did_start_deleting_responses_; int64 last_deletable_response_rowid_; - // AppCacheDiskCache async callbacks - net::OldCompletionCallbackImpl<AppCacheStorageImpl> doom_callback_; - net::OldCompletionCallbackImpl<AppCacheStorageImpl> init_callback_; - // Created on the IO thread, but only used on the DB thread. AppCacheDatabase* database_; diff --git a/webkit/appcache/appcache_update_job.cc b/webkit/appcache/appcache_update_job.cc index 572ba75..31dc325 100644 --- a/webkit/appcache/appcache_update_job.cc +++ b/webkit/appcache/appcache_update_job.cc @@ -4,6 +4,8 @@ #include "webkit/appcache/appcache_update_job.h" +#include "base/bind.h" +#include "base/bind_helpers.h" #include "base/compiler_specific.h" #include "base/message_loop.h" #include "base/string_util.h" @@ -89,12 +91,13 @@ AppCacheUpdateJob::UrlToFetch::~UrlToFetch() { // data out to the disk cache. AppCacheUpdateJob::URLFetcher::URLFetcher( const GURL& url, FetchType fetch_type, AppCacheUpdateJob* job) - : url_(url), job_(job), fetch_type_(fetch_type), retry_503_attempts_(0), + : url_(url), + job_(job), + fetch_type_(fetch_type), + retry_503_attempts_(0), buffer_(new net::IOBuffer(kBufferSize)), ALLOW_THIS_IN_INITIALIZER_LIST( - request_(new net::URLRequest(url, this))), - ALLOW_THIS_IN_INITIALIZER_LIST( - write_callback_(this, &URLFetcher::OnWriteComplete)) { + request_(new net::URLRequest(url, this))) { } AppCacheUpdateJob::URLFetcher::~URLFetcher() { @@ -147,7 +150,9 @@ void AppCacheUpdateJob::URLFetcher::OnResponseStarted( scoped_refptr<HttpResponseInfoIOBuffer> io_buffer( new HttpResponseInfoIOBuffer( new net::HttpResponseInfo(request->response_info()))); - response_writer_->WriteInfo(io_buffer, &write_callback_); + response_writer_->WriteInfo( + io_buffer, + base::Bind(&URLFetcher::OnWriteComplete, base::Unretained(this))); } else { ReadResponseData(); } @@ -236,7 +241,9 @@ bool AppCacheUpdateJob::URLFetcher::ConsumeResponseData(int bytes_read) { case URL_FETCH: case MASTER_ENTRY_FETCH: DCHECK(response_writer_.get()); - response_writer_->WriteData(buffer_, bytes_read, &write_callback_); + response_writer_->WriteData( + buffer_, bytes_read, + base::Bind(&URLFetcher::OnWriteComplete, base::Unretained(this))); return false; // wait for async write completion to continue reading default: NOTREACHED(); @@ -293,13 +300,7 @@ AppCacheUpdateJob::AppCacheUpdateJob(AppCacheService* service, master_entries_completed_(0), url_fetches_completed_(0), manifest_fetcher_(NULL), - stored_state_(UNSTORED), - ALLOW_THIS_IN_INITIALIZER_LIST(manifest_info_write_callback_( - this, &AppCacheUpdateJob::OnManifestInfoWriteComplete)), - ALLOW_THIS_IN_INITIALIZER_LIST(manifest_data_write_callback_( - this, &AppCacheUpdateJob::OnManifestDataWriteComplete)), - ALLOW_THIS_IN_INITIALIZER_LIST(manifest_data_read_callback_( - this, &AppCacheUpdateJob::OnManifestDataReadComplete)) { + stored_state_(UNSTORED) { DCHECK(group_); manifest_url_ = group_->manifest_url(); } @@ -701,8 +702,10 @@ void AppCacheUpdateJob::HandleManifestRefetchCompleted( manifest_response_writer_.reset(CreateResponseWriter()); scoped_refptr<HttpResponseInfoIOBuffer> io_buffer( new HttpResponseInfoIOBuffer(manifest_response_info_.release())); - manifest_response_writer_->WriteInfo(io_buffer, - &manifest_info_write_callback_); + manifest_response_writer_->WriteInfo( + io_buffer, + base::Bind(&AppCacheUpdateJob::OnManifestInfoWriteComplete, + base::Unretained(this))); } } else { VLOG(1) << "Request status: " << request->status().status() @@ -717,8 +720,10 @@ void AppCacheUpdateJob::OnManifestInfoWriteComplete(int result) { if (result > 0) { scoped_refptr<net::StringIOBuffer> io_buffer( new net::StringIOBuffer(manifest_data_)); - manifest_response_writer_->WriteData(io_buffer, manifest_data_.length(), - &manifest_data_write_callback_); + manifest_response_writer_->WriteData( + io_buffer, manifest_data_.length(), + base::Bind(&AppCacheUpdateJob::OnManifestDataWriteComplete, + base::Unretained(this))); } else { HandleCacheFailure("Failed to write the manifest headers to storage"); } @@ -845,15 +850,19 @@ void AppCacheUpdateJob::CheckIfManifestChanged() { group_->group_id(), entry->response_id())); read_manifest_buffer_ = new net::IOBuffer(kBufferSize); - manifest_response_reader_->ReadData(read_manifest_buffer_, kBufferSize, - &manifest_data_read_callback_); // async read + manifest_response_reader_->ReadData( + read_manifest_buffer_, kBufferSize, + base::Bind(&AppCacheUpdateJob::OnManifestDataReadComplete, + base::Unretained(this))); // async read } void AppCacheUpdateJob::OnManifestDataReadComplete(int result) { if (result > 0) { loaded_manifest_data_.append(read_manifest_buffer_->data(), result); - manifest_response_reader_->ReadData(read_manifest_buffer_, kBufferSize, - &manifest_data_read_callback_); // read more + manifest_response_reader_->ReadData( + read_manifest_buffer_, kBufferSize, + base::Bind(&AppCacheUpdateJob::OnManifestDataReadComplete, + base::Unretained(this))); // read more } else { read_manifest_buffer_ = NULL; manifest_response_reader_.reset(); diff --git a/webkit/appcache/appcache_update_job.h b/webkit/appcache/appcache_update_job.h index cb19b24..0f3905e 100644 --- a/webkit/appcache/appcache_update_job.h +++ b/webkit/appcache/appcache_update_job.h @@ -144,7 +144,6 @@ class APPCACHE_EXPORT AppCacheUpdateJob : public AppCacheStorage::Delegate, scoped_refptr<net::HttpResponseHeaders> existing_response_headers_; std::string manifest_data_; scoped_ptr<AppCacheResponseWriter> response_writer_; - net::OldCompletionCallbackImpl<URLFetcher> write_callback_; }; // class URLFetcher AppCacheResponseWriter* CreateResponseWriter(); @@ -305,10 +304,6 @@ class APPCACHE_EXPORT AppCacheUpdateJob : public AppCacheStorage::Delegate, // Whether we've stored the resulting group/cache yet. StoredState stored_state_; - net::OldCompletionCallbackImpl<AppCacheUpdateJob> manifest_info_write_callback_; - net::OldCompletionCallbackImpl<AppCacheUpdateJob> manifest_data_write_callback_; - net::OldCompletionCallbackImpl<AppCacheUpdateJob> manifest_data_read_callback_; - FRIEND_TEST_ALL_PREFIXES(AppCacheGroupTest, QueueUpdate); DISALLOW_COPY_AND_ASSIGN(AppCacheUpdateJob); diff --git a/webkit/appcache/appcache_update_job_unittest.cc b/webkit/appcache/appcache_update_job_unittest.cc index 47b1d42..1d6a4ec 100644 --- a/webkit/appcache/appcache_update_job_unittest.cc +++ b/webkit/appcache/appcache_update_job_unittest.cc @@ -978,18 +978,16 @@ class AppCacheUpdateJobTest : public testing::Test, const std::string seed_data(kManifest1Contents); scoped_refptr<net::StringIOBuffer> io_buffer( new net::StringIOBuffer(seed_data)); - write_callback_.reset( - new net::OldCompletionCallbackImpl<AppCacheUpdateJobTest>(this, - &AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData)); - response_writer_->WriteData(io_buffer, seed_data.length(), - write_callback_.get()); + response_writer_->WriteData( + io_buffer, seed_data.length(), + base::Bind(&AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData, + base::Unretained(this))); // Start update after data write completes asynchronously. } void StartUpdateAfterSeedingStorageData(int result) { ASSERT_GT(result, 0); - write_callback_.reset(); response_writer_.reset(); AppCacheUpdateJob* update = group_->update_job_; @@ -1104,11 +1102,10 @@ class AppCacheUpdateJobTest : public testing::Test, const std::string seed_data("different"); scoped_refptr<net::StringIOBuffer> io_buffer( new net::StringIOBuffer(seed_data)); - write_callback_.reset( - new net::OldCompletionCallbackImpl<AppCacheUpdateJobTest>(this, - &AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData)); - response_writer_->WriteData(io_buffer, seed_data.length(), - write_callback_.get()); + response_writer_->WriteData( + io_buffer, seed_data.length(), + base::Bind(&AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData, + base::Unretained(this))); // Start update after data write completes asynchronously. } @@ -1167,10 +1164,10 @@ class AppCacheUpdateJobTest : public testing::Test, response_info->headers = headers; // adds ref to headers scoped_refptr<HttpResponseInfoIOBuffer> io_buffer( new HttpResponseInfoIOBuffer(response_info)); // adds ref to info - write_callback_.reset( - new net::OldCompletionCallbackImpl<AppCacheUpdateJobTest>(this, - &AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData)); - response_writer_->WriteInfo(io_buffer, write_callback_.get()); + response_writer_->WriteInfo( + io_buffer, + base::Bind(&AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData, + base::Unretained(this))); // Start update after data write completes asynchronously. } @@ -1226,10 +1223,10 @@ class AppCacheUpdateJobTest : public testing::Test, response_info->headers = headers; // adds ref to headers scoped_refptr<HttpResponseInfoIOBuffer> io_buffer( new HttpResponseInfoIOBuffer(response_info)); // adds ref to info - write_callback_.reset( - new net::OldCompletionCallbackImpl<AppCacheUpdateJobTest>(this, - &AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData)); - response_writer_->WriteInfo(io_buffer, write_callback_.get()); + response_writer_->WriteInfo( + io_buffer, + base::Bind(&AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData, + base::Unretained(this))); // Start update after data write completes asynchronously. } @@ -1285,10 +1282,10 @@ class AppCacheUpdateJobTest : public testing::Test, response_info->headers = headers; // adds ref to headers scoped_refptr<HttpResponseInfoIOBuffer> io_buffer( new HttpResponseInfoIOBuffer(response_info)); // adds ref to info - write_callback_.reset( - new net::OldCompletionCallbackImpl<AppCacheUpdateJobTest>(this, - &AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData)); - response_writer_->WriteInfo(io_buffer, write_callback_.get()); + response_writer_->WriteInfo( + io_buffer, + base::Bind(&AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData, + base::Unretained(this))); // Start update after data write completes asynchronously. } @@ -2666,10 +2663,10 @@ class AppCacheUpdateJobTest : public testing::Test, response_info->headers = headers; // adds ref to headers scoped_refptr<HttpResponseInfoIOBuffer> io_buffer( new HttpResponseInfoIOBuffer(response_info)); // adds ref to info - write_callback_.reset( - new net::OldCompletionCallbackImpl<AppCacheUpdateJobTest>(this, - &AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData)); - response_writer_->WriteInfo(io_buffer, write_callback_.get()); + response_writer_->WriteInfo( + io_buffer, + base::Bind(&AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData, + base::Unretained(this))); // Start update after data write completes asynchronously. } @@ -2725,10 +2722,10 @@ class AppCacheUpdateJobTest : public testing::Test, response_info->headers = headers; // adds ref to headers scoped_refptr<HttpResponseInfoIOBuffer> io_buffer( new HttpResponseInfoIOBuffer(response_info)); // adds ref to info - write_callback_.reset( - new net::OldCompletionCallbackImpl<AppCacheUpdateJobTest>(this, - &AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData)); - response_writer_->WriteInfo(io_buffer, write_callback_.get()); + response_writer_->WriteInfo( + io_buffer, + base::Bind(&AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData, + base::Unretained(this))); // Start update after data write completes asynchronously. } @@ -3230,8 +3227,6 @@ class AppCacheUpdateJobTest : public testing::Test, scoped_ptr<base::WaitableEvent> event_; scoped_ptr<AppCacheResponseWriter> response_writer_; - scoped_ptr<net::OldCompletionCallbackImpl<AppCacheUpdateJobTest> > - write_callback_; // Hosts used by an async test that need to live until update job finishes. // Otherwise, test can put host on the stack instead of here. diff --git a/webkit/appcache/appcache_url_request_job.cc b/webkit/appcache/appcache_url_request_job.cc index 2d9b828..7d17909 100644 --- a/webkit/appcache/appcache_url_request_job.cc +++ b/webkit/appcache/appcache_url_request_job.cc @@ -6,6 +6,8 @@ #include "webkit/appcache/appcache_url_request_job.h" +#include "base/bind.h" +#include "base/bind_helpers.h" #include "base/compiler_specific.h" #include "base/message_loop.h" #include "base/string_util.h" @@ -28,8 +30,6 @@ AppCacheURLRequestJob::AppCacheURLRequestJob( delivery_type_(AWAITING_DELIVERY_ORDERS), group_id_(0), cache_id_(kNoCacheId), is_fallback_(false), cache_entry_not_found_(false), - ALLOW_THIS_IN_INITIALIZER_LIST(read_callback_( - this, &AppCacheURLRequestJob::OnReadComplete)), ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) { DCHECK(storage_); } @@ -268,7 +268,9 @@ bool AppCacheURLRequestJob::ReadRawData(net::IOBuffer* buf, int buf_size, DCHECK_NE(buf_size, 0); DCHECK(bytes_read); DCHECK(!reader_->IsReadPending()); - reader_->ReadData(buf, buf_size, &read_callback_); + reader_->ReadData( + buf, buf_size, base::Bind(&AppCacheURLRequestJob::OnReadComplete, + base::Unretained(this))); SetStatus(net::URLRequestStatus(net::URLRequestStatus::IO_PENDING, 0)); return false; } diff --git a/webkit/appcache/appcache_url_request_job.h b/webkit/appcache/appcache_url_request_job.h index 271a777..25b0cf6 100644 --- a/webkit/appcache/appcache_url_request_job.h +++ b/webkit/appcache/appcache_url_request_job.h @@ -139,7 +139,6 @@ class APPCACHE_EXPORT AppCacheURLRequestJob : public net::URLRequestJob, net::HttpByteRange range_requested_; scoped_ptr<net::HttpResponseInfo> range_response_info_; scoped_ptr<AppCacheResponseReader> reader_; - net::OldCompletionCallbackImpl<AppCacheURLRequestJob> read_callback_; base::WeakPtrFactory<AppCacheURLRequestJob> weak_factory_; }; diff --git a/webkit/appcache/appcache_url_request_job_unittest.cc b/webkit/appcache/appcache_url_request_job_unittest.cc index aea70e7..a7ff8b0 100644 --- a/webkit/appcache/appcache_url_request_job_unittest.cc +++ b/webkit/appcache/appcache_url_request_job_unittest.cc @@ -169,14 +169,8 @@ class AppCacheURLRequestJobTest : public testing::Test { } AppCacheURLRequestJobTest() - : ALLOW_THIS_IN_INITIALIZER_LIST(read_callback_( - this, &AppCacheURLRequestJobTest::OnReadComplete)), - ALLOW_THIS_IN_INITIALIZER_LIST(read_info_callback_( - this, &AppCacheURLRequestJobTest::OnReadInfoComplete)), - ALLOW_THIS_IN_INITIALIZER_LIST(write_callback_( - this, &AppCacheURLRequestJobTest::OnWriteComplete)), - ALLOW_THIS_IN_INITIALIZER_LIST(write_info_callback_( - this, &AppCacheURLRequestJobTest::OnWriteInfoComplete)) { + : ALLOW_THIS_IN_INITIALIZER_LIST(read_info_callback_( + this, &AppCacheURLRequestJobTest::OnReadInfoComplete)) { } template <class Method> @@ -287,7 +281,10 @@ class AppCacheURLRequestJobTest : public testing::Test { EXPECT_FALSE(writer_->IsWritePending()); expected_write_result_ = GetHttpResponseInfoSize(head); write_info_buffer_ = new HttpResponseInfoIOBuffer(head); - writer_->WriteInfo(write_info_buffer_, &write_info_callback_); + writer_->WriteInfo( + write_info_buffer_, + base::Bind(&AppCacheURLRequestJobTest::OnWriteInfoComplete, + base::Unretained(this))); } void WriteResponseBody(scoped_refptr<IOBuffer> io_buffer, int buf_len) { @@ -295,7 +292,9 @@ class AppCacheURLRequestJobTest : public testing::Test { write_buffer_ = io_buffer; expected_write_result_ = buf_len; writer_->WriteData( - write_buffer_, buf_len, &write_callback_); + write_buffer_, buf_len, + base::Bind(&AppCacheURLRequestJobTest::OnWriteComplete, + base::Unretained(this))); } void ReadResponseBody(scoped_refptr<IOBuffer> io_buffer, int buf_len) { @@ -303,7 +302,9 @@ class AppCacheURLRequestJobTest : public testing::Test { read_buffer_ = io_buffer; expected_read_result_ = buf_len; reader_->ReadData( - read_buffer_, buf_len, &read_callback_); + read_buffer_, buf_len, + base::Bind(&AppCacheURLRequestJobTest::OnReadComplete, + base::Unretained(this))); } // AppCacheResponseReader / Writer completion callbacks @@ -764,7 +765,6 @@ class AppCacheURLRequestJobTest : public testing::Test { scoped_refptr<HttpResponseInfoIOBuffer> read_info_buffer_; scoped_refptr<IOBuffer> read_buffer_; int expected_read_result_; - net::OldCompletionCallbackImpl<AppCacheURLRequestJobTest> read_callback_; net::OldCompletionCallbackImpl<AppCacheURLRequestJobTest> read_info_callback_; bool should_delete_reader_in_completion_callback_; int reader_deletion_count_down_; @@ -775,8 +775,6 @@ class AppCacheURLRequestJobTest : public testing::Test { scoped_refptr<HttpResponseInfoIOBuffer> write_info_buffer_; scoped_refptr<IOBuffer> write_buffer_; int expected_write_result_; - net::OldCompletionCallbackImpl<AppCacheURLRequestJobTest> write_callback_; - net::OldCompletionCallbackImpl<AppCacheURLRequestJobTest> write_info_callback_; bool should_delete_writer_in_completion_callback_; int writer_deletion_count_down_; bool write_callback_was_called_; diff --git a/webkit/appcache/mock_appcache_storage.h b/webkit/appcache/mock_appcache_storage.h index 424a0f9..94f30dd 100644 --- a/webkit/appcache/mock_appcache_storage.h +++ b/webkit/appcache/mock_appcache_storage.h @@ -115,7 +115,7 @@ class MockAppCacheStorage : public AppCacheStorage { if (!disk_cache_.get()) { const int kMaxCacheSize = 10 * 1024 * 1024; disk_cache_.reset(new AppCacheDiskCache); - disk_cache_->InitWithMemBackend(kMaxCacheSize, NULL); + disk_cache_->InitWithMemBackend(kMaxCacheSize, net::CompletionCallback()); } return disk_cache_.get(); } diff --git a/webkit/appcache/view_appcache_internals_job.cc b/webkit/appcache/view_appcache_internals_job.cc index 3d51b4c..2d0d27c 100644 --- a/webkit/appcache/view_appcache_internals_job.cc +++ b/webkit/appcache/view_appcache_internals_job.cc @@ -505,9 +505,8 @@ class ViewEntryJob : public BaseInternalsJob, int64 response_id, int64 group_id) : BaseInternalsJob(request, service), manifest_url_(manifest_url), entry_url_(entry_url), - response_id_(response_id), group_id_(group_id), amount_read_(0), - ALLOW_THIS_IN_INITIALIZER_LIST(read_callback_( - this, &ViewEntryJob::OnReadComplete)) {} + response_id_(response_id), group_id_(group_id), amount_read_(0) { + } virtual void Start() { DCHECK(request_); @@ -566,7 +565,8 @@ class ViewEntryJob : public BaseInternalsJob, reader_.reset(appcache_service_->storage()->CreateResponseReader( manifest_url_, group_id_, response_id_)); reader_->ReadData( - response_data_, amount_to_read, &read_callback_); + response_data_, amount_to_read, + base::Bind(&ViewEntryJob::OnReadComplete, base::Unretained(this))); } void OnReadComplete(int result) { @@ -585,7 +585,6 @@ class ViewEntryJob : public BaseInternalsJob, scoped_refptr<net::IOBuffer> response_data_; int amount_read_; scoped_ptr<AppCacheResponseReader> reader_; - net::OldCompletionCallbackImpl<ViewEntryJob> read_callback_; }; } // namespace diff --git a/webkit/fileapi/file_system_dir_url_request_job_unittest.cc b/webkit/fileapi/file_system_dir_url_request_job_unittest.cc index fb52cd2..e7871c8 100644 --- a/webkit/fileapi/file_system_dir_url_request_job_unittest.cc +++ b/webkit/fileapi/file_system_dir_url_request_job_unittest.cc @@ -281,21 +281,11 @@ TEST_F(FileSystemDirURLRequestJobTest, NoSuchDirectory) { EXPECT_EQ(net::ERR_FILE_NOT_FOUND, request_->status().error()); } -class QuitNowTask : public Task { - public: - virtual void Run() { - MessageLoop::current()->QuitNow(); - } -}; - TEST_F(FileSystemDirURLRequestJobTest, Cancel) { CreateDirectory("foo"); TestRequestNoRun(CreateFileSystemURL("foo/")); // Run StartAsync() and only StartAsync(). - MessageLoop::current()->PostTask(FROM_HERE, new QuitNowTask); - MessageLoop::current()->Run(); - - request_.reset(); + MessageLoop::current()->DeleteSoon(FROM_HERE, request_.release()); MessageLoop::current()->RunAllPending(); // If we get here, success! we didn't crash! } diff --git a/webkit/fileapi/file_system_url_request_job_unittest.cc b/webkit/fileapi/file_system_url_request_job_unittest.cc index bd0ada8..10f4d0c 100644 --- a/webkit/fileapi/file_system_url_request_job_unittest.cc +++ b/webkit/fileapi/file_system_url_request_job_unittest.cc @@ -335,22 +335,12 @@ TEST_F(FileSystemURLRequestJobTest, NoSuchFile) { EXPECT_EQ(net::ERR_FILE_NOT_FOUND, request_->status().error()); } -class QuitNowTask : public Task { - public: - virtual void Run() { - MessageLoop::current()->QuitNow(); - } -}; - TEST_F(FileSystemURLRequestJobTest, Cancel) { WriteFile("file1.dat", kTestFileData, arraysize(kTestFileData) - 1); TestRequestNoRun(CreateFileSystemURL("file1.dat")); // Run StartAsync() and only StartAsync(). - MessageLoop::current()->PostTask(FROM_HERE, new QuitNowTask); - MessageLoop::current()->Run(); - - request_.reset(); + MessageLoop::current()->DeleteSoon(FROM_HERE, request_.release()); MessageLoop::current()->RunAllPending(); // If we get here, success! we didn't crash! } diff --git a/webkit/fileapi/webfilewriter_base_unittest.cc b/webkit/fileapi/webfilewriter_base_unittest.cc index 088493e..b2c1041 100644 --- a/webkit/fileapi/webfilewriter_base_unittest.cc +++ b/webkit/fileapi/webfilewriter_base_unittest.cc @@ -385,7 +385,7 @@ TEST_F(FileWriterTest, CancelFailedTruncate) { EXPECT_EQ(0, received_did_write_count_); } -TEST_F(FileWriterTest, DeleteInOldCompletionCallbacks) { +TEST_F(FileWriterTest, DeleteInCompletionCallbacks) { delete_in_client_callback_ = true; writer()->write(kBasicFileWrite_Offset, GURL("blob://bloburl/")); EXPECT_FALSE(testable_writer_.get()); diff --git a/webkit/support/test_webmessageportchannel.cc b/webkit/support/test_webmessageportchannel.cc index 8460460..98fae47 100644 --- a/webkit/support/test_webmessageportchannel.cc +++ b/webkit/support/test_webmessageportchannel.cc @@ -4,6 +4,7 @@ #include "webkit/support/test_webmessageportchannel.h" +#include "base/bind.h" #include "base/memory/scoped_ptr.h" #include "base/message_loop.h" #include "base/task.h" @@ -66,9 +67,8 @@ void TestWebMessagePortChannel::postMessage(const WebString& data, return; MessageLoop::current()->PostTask( FROM_HERE, - NewRunnableMethod(remote_.get(), - &TestWebMessagePortChannel::queueMessage, - new Message(data, ports))); + base::Bind(&TestWebMessagePortChannel::queueMessage, remote_.get(), + new Message(data, ports))); } bool TestWebMessagePortChannel::tryGetMessage(WebString* data, |